Expression.h

Go to the documentation of this file.

//
// Class Expression
//   Expression to be evaluated in the framework.
//
//   @see GlobalFunctions.h
//
//   This class parses and evaluates string expressions (objectives or
//   constraints) using a hand-written recursive-descent parser.
//   Custom functions called in the expression should be registered by the
//   driver. A collection of C math default functions is always included.
//   For constraints the operator type can be queried.
//
// Copyright (c) 2010 - 2013, Yves Ineichen, ETH Zürich
// All rights reserved
//
// Implemented as part of the PhD thesis
// "Toward massively parallel multi-objective optimization with application to
// particle accelerators" (https://doi.org/10.3929/ethz-a-009792359)
//
// This file is part of OPAL.
//
// OPAL 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 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef __EXPRESSION_H__
#define __EXPRESSION_H__
 
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <string_view>
#include <tuple>
#include <variant>
 
#include "Util/Types.h"
#include "Util/OptPilotException.h"
 
#include "Expression/Parser/expression.hpp"
#include "Expression/Parser/evaluator.hpp"
#include "Expression/Parser/requirements.hpp"
#include "Expression/Parser/function.hpp"
 
 
typedef std::map<std::string, double> variableDictionary_t;
typedef std::map<std::string, client::function::type> functionDictionary_t;
 
class Expression;
namespace Expressions {
 
    typedef Expression Expr_t;
 
    // result of an evaluated expression
    typedef std::tuple<double, bool> Result_t;
    enum Result_tIdx{
        VALUE,
        IS_VALID
    };
 
    //FIXME: this actually should be a map of type (name, fusion::vector<...>)
    typedef std::map<std::string, Expressions::Expr_t*> Named_t;
 
    //XXX name of one single expression
    typedef std::pair<std::string, Expressions::Expr_t*> SingleNamed_t;
 
    enum class OperatorType_t {
        NONE,
        EQ,             // ==
        NOT_EQ,         // !=
        INEQ_LHS,       // <
        INEQ_LHS_EQ,    // <=
        INEQ_RHS,       // >
        INEQ_RHS_EQ     // >=
    };
}
 
#include "Expression/GlobalFunctions.h"
 
class Expression {
 
public:
    Expression()
    {}
 
    Expression(std::string expr)
        : expr_(expr)
    {
        determineConstrOperator();
        functionDictionary_t global_funcs = GlobalFunctions::get();
        known_expr_funcs_.insert(global_funcs.begin(), global_funcs.end());
        parse();
    }
 
    Expression(std::string expr, functionDictionary_t known_expr_funcs)
        : expr_(std::move(expr))
        , known_expr_funcs_(known_expr_funcs)
    {
        determineConstrOperator();
        functionDictionary_t global_funcs = GlobalFunctions::get();
        known_expr_funcs_.insert(global_funcs.begin(), global_funcs.end());
        parse();
    }
 
    virtual ~Expression()
    {}
 
    const std::set<std::string>& getReqVars()  const { return vars_; }
    const std::set<std::string>& getReqFuncs() const { return funcs_; }
    const std::string&           toString()    const { return expr_; }
 
    functionDictionary_t getRegFuncs()  const { return known_expr_funcs_; }
 
    Expressions::OperatorType_t getOpType() const { return type_; }
 
    Expressions::Result_t evaluate(const variableDictionary_t& vars) {
 
        iterator_type iter = expr_.begin();
        iterator_type end  = expr_.end();
        client::error_handler<iterator_type> error_handler(iter, end);
        client::code_gen::StackEvaluator     evaluator(error_handler);
        evaluator.registerVariables(vars);
        evaluator.registerFunctions(known_expr_funcs_);
 
        double result = 0.0;
        bool   valid  = false;
        if (evaluator(ast_)) {
            result = evaluator.result();
            valid  = true;
        }
 
        return std::make_tuple(result, valid);
    }
 
private:
    typedef std::string::const_iterator iterator_type;
    client::ast::expression ast_;
 
    std::set<std::string> vars_;
    std::set<std::string> funcs_;
 
    std::string expr_;
    functionDictionary_t known_expr_funcs_;
 
    Expressions::OperatorType_t type_;
 
    void determineConstrOperator() {
        type_ = Expressions::OperatorType_t::NONE;
        std::string_view op(expr_);
 
        constexpr std::pair<std::string_view, Expressions::OperatorType_t> op_map[] = {
            {"==", Expressions::OperatorType_t::EQ},
            {"!=", Expressions::OperatorType_t::NOT_EQ},
            {"<=", Expressions::OperatorType_t::INEQ_LHS_EQ},
            {">=", Expressions::OperatorType_t::INEQ_RHS_EQ},
            {"<",  Expressions::OperatorType_t::INEQ_LHS},
            {">",  Expressions::OperatorType_t::INEQ_RHS}
        };
 
        for (const auto& p : op_map) {
            if (op.find(p.first) != std::string_view::npos) {
                type_ = p.second;
                break;
            }
        }
    }
 
    void parse() {
        iterator_type iter = expr_.begin();
        iterator_type end  = expr_.end();
 
        client::error_handler<iterator_type>       error_handler(iter, end);
        client::parser::expression<iterator_type>  expression(error_handler);
        client::code_gen::requirements             requirements(error_handler);
 
        bool success = expression.parse(iter, end, ast_);
 
        if (!success || iter != end) {
            std::cout << "Parsing failed!" << std::endl;
            std::string here = (iter != end ? std::string(iter, end): expr_);
            throw OptPilotException("Expression::parse()",
                                     "Parsing failed here: " + here + "!");
        }
 
        // store the functions and variables required to evaluate this
        // expression
        if (requirements(ast_)) {
            vars_ = requirements.variables();
            funcs_ = requirements.functions();
        }
    }
};
 
#endif