Equality visitor

src/solver/expressions/CMakeLists.txt

@@ -12,6 +12,7 @@ set(SRC_Expressions
         visitors/EvalVisitor.cpp
         visitors/LinearityVisitor.cpp
         visitors/EvaluationContext.cpp
+        visitors/EqualityVisitor.cpp
 
         include/antares/solver/expressions/nodes/ParentNode.h
         include/antares/solver/expressions/nodes/UnaryNode.h
@@ -34,6 +35,7 @@ set(SRC_Expressions
         include/antares/solver/expressions/nodes/ParameterNode.h
         include/antares/solver/expressions/nodes/PortFieldNode.h
         include/antares/solver/expressions/nodes/NodeVisitor.h
+        include/antares/solver/expressions/nodes/TwoNodesVisitor.h
         include/antares/solver/expressions/nodes/VariableNode.h
 
         include/antares/solver/expressions/visitors/CloneVisitor.h
@@ -42,6 +44,7 @@ set(SRC_Expressions
         include/antares/solver/expressions/visitors/PrintVisitor.h
         include/antares/solver/expressions/visitors/LinearStatus.h
         include/antares/solver/expressions/visitors/LinearityVisitor.h
+        include/antares/solver/expressions/visitors/EqualityVisitor.h
 
         include/antares/solver/expressions/Registry.hxx
 )

src/solver/expressions/include/antares/solver/expressions/nodes/ComponentNode.h

@@ -31,6 +31,7 @@ class ComponentNode: public Node
     explicit ComponentNode(const std::string& component_id, const std::string& component_name);
     const std::string& getComponentId() const;
     const std::string& getComponentName() const;
+    bool operator==(const ComponentNode& other) const;
 
 private:
     std::string component_id_;

src/solver/expressions/include/antares/solver/expressions/nodes/PortFieldNode.h

@@ -32,6 +32,7 @@ class PortFieldNode: public Node
     explicit PortFieldNode(const std::string& port_name, const std::string& field_name);
     const std::string& getPortName() const;
     const std::string& getFieldName() const;
+    bool operator==(const PortFieldNode& other) const;
 
 private:
     std::string port_name_;

src/solver/expressions/include/antares/solver/expressions/nodes/TwoNodesVisitor.h

@@ -0,0 +1,98 @@
+/*
+** Copyright 2007-2024, RTE (https://www.rte-france.com)
+** See AUTHORS.txt
+** SPDX-License-Identifier: MPL-2.0
+** This file is part of Antares-Simulator,
+** Adequacy and Performance assessment for interconnected energy networks.
+**
+** Antares_Simulator is free software: you can redistribute it and/or modify
+** it under the terms of the Mozilla Public Licence 2.0 as published by
+** the Mozilla Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** Antares_Simulator 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
+** Mozilla Public Licence 2.0 for more details.
+**
+** You should have received a copy of the Mozilla Public Licence 2.0
+** along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
+*/
+#pragma once
+#include <optional>
+#include <vector>
+
+#include <antares/logs/logs.h>
+#include <antares/solver/expressions/nodes/NodesForwardDeclaration.h>
+
+namespace Antares::Solver::Nodes
+{
+namespace
+{
+template<class RetT, class VisitorT, class NodeT>
+std::optional<RetT> tryType(const Node& node1, const Node& node2, VisitorT& visitor)
+{
+    auto x = dynamic_cast<const NodeT*>(&node1);
+    auto y = dynamic_cast<const NodeT*>(&node2);
+    if (x && y)
+    {
+        return visitor.visit(*x, *y);
+    }
+    else
+    {
+        return {};
+    }
+}
+} // namespace
+
+template<class R>
+class TwoNodesVisitor
+{
+public:
+    virtual ~TwoNodesVisitor() = default;
+
+    R dispatch(const Node& node1, const Node& node2)
+    {
+        using FunctionT = std::optional<R> (*)(const Node&, const Node&, TwoNodesVisitor<R>&);
+        std::vector<FunctionT> functions{&tryType<R, TwoNodesVisitor<R>, AddNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, SubtractionNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, MultiplicationNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, DivisionNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, EqualNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, LessThanOrEqualNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, GreaterThanOrEqualNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, NegationNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, ParameterNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, VariableNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, LiteralNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, PortFieldNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, ComponentVariableNode>,
+                                         &tryType<R, TwoNodesVisitor<R>, ComponentParameterNode>};
+        for (auto f: functions)
+        {
+            if (auto ret = f(node1, node2, *this); ret.has_value())
+            {
+                return ret.value();
+            }
+        }
+        logs.error() << "Antares::Solver::Nodes Visitor: unsupported Node!";
+        return R();
+    }
+
+    virtual R visit(const AddNode&, const AddNode&) = 0;
+    virtual R visit(const SubtractionNode&, const SubtractionNode&) = 0;
+    virtual R visit(const MultiplicationNode&, const MultiplicationNode&) = 0;
+    virtual R visit(const DivisionNode&, const DivisionNode&) = 0;
+    virtual R visit(const EqualNode&, const EqualNode&) = 0;
+    virtual R visit(const LessThanOrEqualNode&, const LessThanOrEqualNode&) = 0;
+    virtual R visit(const GreaterThanOrEqualNode&, const GreaterThanOrEqualNode&) = 0;
+    virtual R visit(const NegationNode&, const NegationNode&) = 0;
+    virtual R visit(const LiteralNode&, const LiteralNode&) = 0;
+    virtual R visit(const VariableNode&, const VariableNode&) = 0;
+    virtual R visit(const ParameterNode&, const ParameterNode&) = 0;
+    virtual R visit(const PortFieldNode&, const PortFieldNode&) = 0;
+    virtual R visit(const ComponentVariableNode&, const ComponentVariableNode&) = 0;
+    virtual R visit(const ComponentParameterNode&, const ComponentParameterNode&) = 0;
+};
+
+} // namespace Antares::Solver::Nodes

src/solver/expressions/include/antares/solver/expressions/visitors/EqualityVisitor.h

@@ -0,0 +1,55 @@
+/*
+** Copyright 2007-2024, RTE (https://www.rte-france.com)
+** See AUTHORS.txt
+** SPDX-License-Identifier: MPL-2.0
+** This file is part of Antares-Simulator,
+** Adequacy and Performance assessment for interconnected energy networks.
+**
+** Antares_Simulator is free software: you can redistribute it and/or modify
+** it under the terms of the Mozilla Public Licence 2.0 as published by
+** the Mozilla Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** Antares_Simulator 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
+** Mozilla Public Licence 2.0 for more details.
+**
+** You should have received a copy of the Mozilla Public Licence 2.0
+** along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
+*/
+#pragma once
+
+#include "antares/solver/expressions/nodes/TwoNodesVisitor.h"
+
+namespace Antares::Solver::Visitors
+{
+
+class EqualityVisitor: public Nodes::TwoNodesVisitor<bool>
+{
+public:
+    using Base = Nodes::TwoNodesVisitor<bool>;
+
+private:
+    bool visit(const Nodes::AddNode& add1, const Nodes::AddNode& add2) override;
+    bool visit(const Nodes::SubtractionNode& add1, const Nodes::SubtractionNode& add2) override;
+    bool visit(const Nodes::MultiplicationNode& add1,
+               const Nodes::MultiplicationNode& add2) override;
+    bool visit(const Nodes::DivisionNode& add1, const Nodes::DivisionNode& add2) override;
+    bool visit(const Nodes::EqualNode& add1, const Nodes::EqualNode& add2) override;
+    bool visit(const Nodes::LessThanOrEqualNode& add1,
+               const Nodes::LessThanOrEqualNode& add2) override;
+    bool visit(const Nodes::GreaterThanOrEqualNode& add1,
+               const Nodes::GreaterThanOrEqualNode& add2) override;
+    bool visit(const Nodes::NegationNode& neg1, const Nodes::NegationNode& neg2) override;
+    bool visit(const Nodes::VariableNode& param1, const Nodes::VariableNode& param2) override;
+    bool visit(const Nodes::ParameterNode& param1, const Nodes::ParameterNode& param2) override;
+    bool visit(const Nodes::LiteralNode& lit1, const Nodes::LiteralNode& lit2) override;
+    bool visit(const Nodes::PortFieldNode& port_field_node1,
+               const Nodes::PortFieldNode& port_field_node2) override;
+    bool visit(const Nodes::ComponentVariableNode& component_variable_node1,
+               const Nodes::ComponentVariableNode& component_variable_node2) override;
+    bool visit(const Nodes::ComponentParameterNode& component_parameter_node1,
+               const Nodes::ComponentParameterNode& component_parameter_node2) override;
+};
+} // namespace Antares::Solver::Visitors

src/solver/expressions/nodes/ComponentNode.cpp

@@ -37,4 +37,9 @@ const std::string& ComponentNode::getComponentName() const
 {
     return component_name_;
 }
+
+bool ComponentNode::operator==(const ComponentNode& other) const
+{
+    return (component_id_ == other.component_id_) && (component_name_ == other.component_name_);
+}
 } // namespace Antares::Solver::Nodes

src/solver/expressions/nodes/PortFieldNode.cpp

@@ -37,4 +37,9 @@ const std::string& PortFieldNode::getFieldName() const
 {
     return field_name_;
 }
+
+bool PortFieldNode::operator==(const PortFieldNode& other) const
+{
+    return (port_name_ == other.port_name_) && (field_name_ == other.field_name_);
+}
 } // namespace Antares::Solver::Nodes

src/solver/expressions/visitors/EqualityVisitor.cpp

@@ -0,0 +1,83 @@
+#include <antares/solver/expressions/nodes/ExpressionsNodes.h>
+#include <antares/solver/expressions/visitors/EqualityVisitor.h>
+
+namespace Antares::Solver::Visitors
+{
+
+bool EqualityVisitor::visit(const Nodes::AddNode& add1, const Nodes::AddNode& add2)
+{
+    return dispatch(*add1[0], *add2[0]) && dispatch(*add1[1], *add2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::SubtractionNode& sub1, const Nodes::SubtractionNode& sub2)
+{
+    return dispatch(*sub1[0], *sub2[0]) && dispatch(*sub1[1], *sub2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::MultiplicationNode& mult1,
+                            const Nodes::MultiplicationNode& mult2)
+{
+    return dispatch(*mult1[0], *mult2[0]) && dispatch(*mult1[1], *mult2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::DivisionNode& div1, const Nodes::DivisionNode& div2)
+{
+    return dispatch(*div1[0], *div2[0]) && dispatch(*div1[1], *div2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::EqualNode& equ1, const Nodes::EqualNode& equ2)
+{
+    return dispatch(*equ1[0], *equ2[0]) && dispatch(*equ1[1], *equ2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::LessThanOrEqualNode& lt1,
+                            const Nodes::LessThanOrEqualNode& lt2)
+{
+    return dispatch(*lt1[0], *lt2[0]) && dispatch(*lt1[1], *lt2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::GreaterThanOrEqualNode& gt1,
+                            const Nodes::GreaterThanOrEqualNode& gt2)
+{
+    return dispatch(*gt1[0], *gt2[0]) && dispatch(*gt1[1], *gt2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::VariableNode& var1, const Nodes::VariableNode& var2)
+{
+    return var1.getValue() == var2.getValue();
+}
+
+bool EqualityVisitor::visit(const Nodes::ParameterNode& param1, const Nodes::ParameterNode& param2)
+{
+    return param1.getValue() == param2.getValue();
+}
+
+bool EqualityVisitor::visit(const Nodes::LiteralNode& lit1, const Nodes::LiteralNode& lit2)
+{
+    return lit1.getValue() == lit1.getValue();
+}
+
+bool EqualityVisitor::visit(const Nodes::NegationNode& neg1, const Nodes::NegationNode& neg2)
+{
+    return dispatch(*neg1[0], *neg2[0]) && dispatch(*neg1[1], *neg2[1]);
+}
+
+bool EqualityVisitor::visit(const Nodes::PortFieldNode& port_field_node1,
+                            const Nodes::PortFieldNode& port_field_node2)
+{
+    return port_field_node1 == port_field_node2;
+}
+
+bool EqualityVisitor::visit(const Nodes::ComponentVariableNode& component_variable_node1,
+                            const Nodes::ComponentVariableNode& component_variable_node2)
+{
+    return component_variable_node1 == component_variable_node2;
+}
+
+bool EqualityVisitor::visit(const Nodes::ComponentParameterNode& component_parameter_node1,
+                            const Nodes::ComponentParameterNode& component_parameter_node2)
+{
+    return component_parameter_node1 == component_parameter_node2;
+}
+
+} // namespace Antares::Solver::Visitors

src/tests/src/solver/expressions/test_expressions.cpp

@@ -27,6 +27,7 @@
 #include <antares/solver/expressions/Registry.hxx>
 #include <antares/solver/expressions/nodes/ExpressionsNodes.h>
 #include <antares/solver/expressions/visitors/CloneVisitor.h>
+#include <antares/solver/expressions/visitors/EqualityVisitor.h>
 #include <antares/solver/expressions/visitors/EvalVisitor.h>
 #include <antares/solver/expressions/visitors/LinearStatus.h>
 #include <antares/solver/expressions/visitors/LinearityVisitor.h>
@@ -375,3 +376,37 @@ BOOST_FIXTURE_TEST_CASE(simple_constant_expression, Registry<Node>)
     BOOST_CHECK_EQUAL(printVisitor.dispatch(*expr), "((65.000000*p1)+port.field)");
     BOOST_CHECK_EQUAL(linearVisitor.dispatch(*expr), LinearStatus::CONSTANT);
 }
+
+BOOST_FIXTURE_TEST_CASE(equality_test_two_addition_nodes, Registry<Node>)
+{
+    LiteralNode lit1(65.), lit2(65.);
+    // variable
+    VariableNode x1("x"), x2("x");
+
+    // Mult : 65.*x
+    Node* u1 = create<MultiplicationNode>(&lit1, &x1);
+    Node* u2 = create<MultiplicationNode>(&lit2, &x2);
+    LiteralNode lit3(56.);
+    LiteralNode lit4(56.);
+    // variable
+    VariableNode y1("y");
+    VariableNode y2("y");
+    // Mult : 56.*y
+    Node* v1 = create<MultiplicationNode>(&lit3, &y1);
+    Node* v2 = create<MultiplicationNode>(&lit4, &y2);
+
+    Node* add1 = create<AddNode>(u1, v1);
+    CloneVisitor cloneVisitor(*this);
+    Node* add1_clone = cloneVisitor.dispatch(*add1);
+
+    Node* add2 = create<AddNode>(u2, v2);
+
+    PrintVisitor printVisitor;
+    EqualityVisitor equalityVisitor;
+
+    BOOST_CHECK_EQUAL(printVisitor.dispatch(*add1), printVisitor.dispatch(*add1_clone));
+    BOOST_CHECK_EQUAL(equalityVisitor.dispatch(*add1, *add2), true);
+    // TODO test depth
+    AddNode random_add(create<LiteralNode>(25.), create<VariableNode>("rand_var"));
+    BOOST_CHECK_EQUAL(equalityVisitor.dispatch(*add1, random_add), false);
+}