[ANT-2749] Support time dependency

src/expressions/CMakeLists.txt

@@ -84,6 +84,8 @@ target_link_libraries(expressions
         PUBLIC
         Boost::headers
         Antares::logs
+        #TODO i need LinearProblemData
+        linear-problem-api
 )
 
 

src/expressions/include/antares/expressions/visitors/EvalVisitor.h

@@ -20,9 +20,17 @@
 */
 #pragma once
 
+#include <cmath>
+
 #include <antares/expressions/visitors/EvaluationContext.h>
+#include <antares/optimisation/linear-problem-api/ILinearProblemData.h>
 #include "antares/expressions/visitors/NodeVisitor.h"
 
+namespace Antares::Optimisation::LinearProblemApi
+{
+struct DataSeriesKeys;
+}
+
 namespace Antares::Expressions::Visitors
 {
 
@@ -37,42 +45,195 @@ class EvalVisitorNotImplemented: public std::invalid_argument
 public:
     EvalVisitorNotImplemented(const std::string& visitor, const std::string& node);
 };
+enum class EvaluationResultType : bool
+{
+    CONSTANT = true,
+    NOTCONSTANT = false
+};
+
+class EvaluationResult
+{
+public:
+    explicit EvaluationResult(double value);
+
+    explicit EvaluationResult(const std::vector<double>& values);
+
+    EvaluationResult operator+(const EvaluationResult& right) const
+    {
+        return applyOperator(right, std::plus<>());
+    }
+
+    EvaluationResult operator-(const EvaluationResult& right) const
+    {
+        return applyOperator(right, std::minus<>());
+    }
+
+    EvaluationResult operator*(const EvaluationResult& right) const
+    {
+        return applyOperator(right, std::multiplies<>());
+    }
+
+    struct SafeDivides
+    {
+        double operator()(double lhs, double rhs) const
+        {
+            // if (rhs == 0.0)
+            // {
+            //     throw std::runtime_error("Division by zero in EvaluationResult.");
+            // }
+            double result{0.};
+            try
+            {
+                result = lhs / rhs;
+
+                if (!std::isfinite(result))
+                {
+                    throw EvalVisitorDivisionException(lhs, rhs, "is not a finite number");
+                }
+            }
+            catch (const std::exception& ex)
+            {
+                throw EvalVisitorDivisionException(lhs, rhs, ex.what());
+            }
+
+            return result;
+        }
+    };
+
+    EvaluationResult operator/(const EvaluationResult& right) const
+    {
+        // return applyOperator(right, std::divides<>());
+        return applyOperator(right, SafeDivides{});
+    }
+
+    EvaluationResult operator-() const
+    {
+        return applyUnaryOperator(std::negate<>());
+    }
+
+    [[nodiscard]] double value() const
+    {
+        return value_;
+    }
+
+    [[nodiscard]] std::vector<double> values() const
+    {
+        return values_;
+    }
+
+    [[nodiscard]] EvaluationResultType getEvaluationResultType() const
+    {
+        return evaluationResultType;
+    }
+
+private:
+    double value_ = 0.;
+    std::vector<double> values_ = {};
+    EvaluationResultType evaluationResultType;
+
+    template<typename Op>
+    EvaluationResult applyOperator(const EvaluationResult& right, Op op) const;
+    template<typename Op>
+    EvaluationResult applyUnaryOperator(Op op) const;
+};
+
+template<typename Op>
+EvaluationResult EvaluationResult::applyOperator(const EvaluationResult& right, Op op) const
+{
+    EvaluationResult result(0.0);
+
+    if (evaluationResultType == EvaluationResultType::CONSTANT
+        && right.evaluationResultType == EvaluationResultType::CONSTANT)
+    {
+        result.value_ = op(value_, right.value_);
+    }
+    else if (evaluationResultType == EvaluationResultType::CONSTANT)
+    {
+        result.values_ = right.values_;
+        for (double& v: result.values_)
+        {
+            v = op(value_, v);
+        }
+    }
+    else if (right.evaluationResultType == EvaluationResultType::CONSTANT)
+    {
+        result.values_ = values_;
+        for (double& v: result.values_)
+        {
+            v = op(v, right.value_);
+        }
+    }
+    else if (values_.size() == right.values_.size())
+    {
+        result.values_ = values_;
+        for (size_t i = 0; i < values_.size(); ++i)
+        {
+            result.values_[i] = op(values_[i], right.values_[i]);
+        }
+    }
+
+    return result;
+}
+
+template<typename Op>
+EvaluationResult EvaluationResult::applyUnaryOperator(Op op) const
+{
+    EvaluationResult result(0.0);
+
+    if (evaluationResultType == EvaluationResultType::CONSTANT)
+    {
+        result.value_ = op(value_);
+    }
+    else
+    {
+        result.values_ = values_;
+        for (double& v: result.values_)
+        {
+            v = op(v);
+        }
+    }
+
+    return result;
+}
 
 /**
  * @brief Represents a visitor for evaluating expressions within a given context.
  */
-class EvalVisitor: public NodeVisitor<double>
+class EvalVisitor: public NodeVisitor<EvaluationResult>
 {
 public:
     /**
      * @brief Default constructor, creates an evaluation visitor with no context.
      */
-    EvalVisitor() = default; // No context (variables / parameters)
+    // EvalVisitor() = default; // No context (variables / parameters)
 
     /**
      * @brief Constructs an evaluation visitor with the specified context.
      *
      * @param context The evaluation context.
+     * @param dataSeriesKeys
      */
-    explicit EvalVisitor(EvaluationContext context);
+    explicit EvalVisitor(EvaluationContext context,
+                         Optimisation::LinearProblemApi::DataSeriesKeys dataSeriesKeys);
     std::string name() const override;
 
 private:
     const EvaluationContext context_;
-    double visit(const Nodes::SumNode* node) override;
-    double visit(const Nodes::SubtractionNode* node) override;
-    double visit(const Nodes::MultiplicationNode* node) override;
-    double visit(const Nodes::DivisionNode* node) override;
-    double visit(const Nodes::EqualNode* node) override;
-    double visit(const Nodes::LessThanOrEqualNode* node) override;
-    double visit(const Nodes::GreaterThanOrEqualNode* node) override;
-    double visit(const Nodes::NegationNode* node) override;
-    double visit(const Nodes::VariableNode* node) override;
-    double visit(const Nodes::ParameterNode* node) override;
-    double visit(const Nodes::LiteralNode* node) override;
-    double visit(const Nodes::PortFieldNode* node) override;
-    double visit(const Nodes::PortFieldSumNode* node) override;
-    double visit(const Nodes::ComponentVariableNode* node) override;
-    double visit(const Nodes::ComponentParameterNode* node) override;
+    Optimisation::LinearProblemApi::DataSeriesKeys dataSeriesKeys_;
+    EvaluationResult visit(const Nodes::SumNode* node) override;
+    EvaluationResult visit(const Nodes::SubtractionNode* node) override;
+    EvaluationResult visit(const Nodes::MultiplicationNode* node) override;
+    EvaluationResult visit(const Nodes::DivisionNode* node) override;
+    EvaluationResult visit(const Nodes::EqualNode* node) override;
+    EvaluationResult visit(const Nodes::LessThanOrEqualNode* node) override;
+    EvaluationResult visit(const Nodes::GreaterThanOrEqualNode* node) override;
+    EvaluationResult visit(const Nodes::NegationNode* node) override;
+    EvaluationResult visit(const Nodes::VariableNode* node) override;
+    EvaluationResult visit(const Nodes::ParameterNode* node) override;
+    EvaluationResult visit(const Nodes::LiteralNode* node) override;
+    EvaluationResult visit(const Nodes::PortFieldNode* node) override;
+    EvaluationResult visit(const Nodes::PortFieldSumNode* node) override;
+    EvaluationResult visit(const Nodes::ComponentVariableNode* node) override;
+    EvaluationResult visit(const Nodes::ComponentParameterNode* node) override;
 };
 } // namespace Antares::Expressions::Visitors

src/expressions/include/antares/expressions/visitors/EvaluationContext.h

@@ -2,9 +2,29 @@
 
 #include <map>
 #include <string>
+#include <vector>
+
+namespace Antares::Optimisation::LinearProblemApi
+{
+class ILinearProblemData;
+}
 
 namespace Antares::Expressions::Visitors
 {
+enum class ParameterType : unsigned int
+{
+    CONSTANT = 0,
+    TIMESERIE = 1
+};
+
+// TODO this struct is exactly the same as the one in system.h
+struct ContextParameter
+{
+    std::string id;
+    ParameterType type;
+    std::string value;
+};
+
 /**
  * @brief Represents the context for evaluating expressions.
  *
@@ -17,16 +37,17 @@ class EvaluationContext
      * @brief Default constructor, creates an evaluation context without parameter and variable
      * values.
      */
-    EvaluationContext() = default;
+    // EvaluationContext() = default;
     /**
      * @brief Constructs an evaluation context with the specified parameter and variable
      * values.
      *
-     * @param parameters parameter values.
+     * @param constant_parameters parameter values.
      * @param variables variable values.
      */
-    explicit EvaluationContext(std::map<std::string, double> parameters,
-                               std::map<std::string, double> variables);
+    explicit EvaluationContext(std::map<std::string, ContextParameter> system_parameters,
+                               std::map<std::string, double> variables,
+                               Optimisation::LinearProblemApi::ILinearProblemData& data);
 
     /**
      * @brief Retrieves the value of a variable.
@@ -44,18 +65,31 @@ class EvaluationContext
      * @return The value of the parameter.
      * @throws std::out_of_range If the parameter is not found.
      */
-    double getParameterValue(const std::string& key) const;
+    double getSystemParameterValueAsDouble(const std::string& key) const;
+    std::string getSystemParameterValue(const std::string& key) const;
+
+    std::vector<double> getParameterValue(const std::string& key,
+                                          const std::string& scenarioGroup,
+                                          const unsigned scenario) const;
+    double getParameterValue(const std::string& key,
+                             const std::string& scenarioGroup,
+                             const unsigned scenario,
+                             unsigned int hour) const;
+
+    ParameterType getParameterType(const std::string& key) const;
+    ContextParameter getParameter(const std::string& key) const;
 
 private:
     /**
      * @brief A map storing parameter values.
      */
-    std::map<std::string, double> parameters_;
+    std::map<std::string, ContextParameter> system_parameters_;
 
     /**
      * @brief A map storing variable values.
      */
     std::map<std::string, double> variables_;
+    Optimisation::LinearProblemApi::ILinearProblemData& data_;
 };
 
 } // namespace Antares::Expressions::Visitors