Rewrite of is_functionally_identical behavior (#366)

* change default is_functionally_identical to return false so if an op forgets to override it gets a behavior that might be slower to compile but it will at least work

src/ngraph/node.cpp

@@ -337,6 +337,11 @@ bool Node::has_same_type(std::shared_ptr<const Node> node) const
 }
 
 bool Node::is_functionally_identical(const Node& other) const
+{
+    return false;
+}
+
+bool Node::test_identical(const Node& other) const
 {
     bool rc = true;
     if (this->description() == other.description())

src/ngraph/node.hpp

@@ -171,6 +171,7 @@ namespace ngraph
     protected:
         void add_output(const element::Type& element_type, const Shape& shape);
         void assert_argument_list_equivalency(const Nodes& b);
+        bool test_identical(const Node&) const;
 
         std::string m_node_type;
         std::multiset<Node*> m_users;

src/ngraph/ops/abs.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Abs::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta * std::make_shared<op::Sign>(x));
 }
+
+bool ngraph::op::Abs::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/abs.hpp

@@ -53,6 +53,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Abs>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/acos.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Acos>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/add.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Add::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(x, delta);
     adjoints.add_delta(y, delta);
 }
+
+bool ngraph::op::Add::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/add.hpp

@@ -55,6 +55,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Add>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/asin.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Asin>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/atan.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Atan>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/broadcast.cpp

@@ -49,7 +49,7 @@ void op::Broadcast::generate_adjoints(autodiff::Adjoints& adjoints,
 bool op::Broadcast::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Broadcast& obj = dynamic_cast<const Broadcast&>(other);
         rc &= m_shape == obj.m_shape;

src/ngraph/ops/ceiling.hpp

@@ -51,6 +51,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Ceiling>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/concatenate.cpp

@@ -106,7 +106,7 @@ void op::Concat::generate_adjoints(autodiff::Adjoints& adjoints, const std::shar
 bool op::Concat::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Concat& concat = dynamic_cast<const Concat&>(other);
         rc &= m_concatenation_axis == concat.m_concatenation_axis;

src/ngraph/ops/convert.cpp

@@ -40,7 +40,7 @@ void ngraph::op::Convert::generate_adjoints(autodiff::Adjoints& adjoints,
 bool op::Convert::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Convert& obj = dynamic_cast<const Convert&>(other);
         rc &= m_element_type == obj.m_element_type;

src/ngraph/ops/convolution.cpp

@@ -294,7 +294,7 @@ std::shared_ptr<Node>
 bool op::Convolution::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Convolution& rhs = dynamic_cast<const Convolution&>(other);
         rc &= m_window_movement_strides == rhs.m_window_movement_strides;

src/ngraph/ops/cos.cpp

@@ -24,3 +24,8 @@ void ngraph::op::Cos::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, -delta * (std::make_shared<op::Sin>(x)));
 }
+
+bool ngraph::op::Cos::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/cos.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Cos>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/cosh.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Cosh::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta * (std::make_shared<op::Sinh>(x)));
 }
+
+bool ngraph::op::Cosh::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/cosh.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Cosh>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/divide.cpp

@@ -25,3 +25,8 @@ void ngraph::op::Divide::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(x, delta * shared_from_this() / x);
     adjoints.add_delta(y, -delta * shared_from_this() / y);
 }
+
+bool ngraph::op::Divide::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/divide.hpp

@@ -56,6 +56,7 @@ namespace ngraph
 
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,
                                            const std::shared_ptr<Node>& delta) override;
+            bool is_functionally_identical(const Node&) const override;
         };
     }
     inline std::shared_ptr<ngraph::Node> operator/(const std::shared_ptr<ngraph::Node> arg0,

src/ngraph/ops/dot.cpp

@@ -147,7 +147,7 @@ void op::Dot::generate_adjoints(autodiff::Adjoints& adjoints, const std::shared_
 bool op::Dot::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Dot& rhs = dynamic_cast<const Dot&>(other);
         rc &= m_reduction_axes_count == rhs.m_reduction_axes_count;

src/ngraph/ops/equal.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Equal>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/exp.cpp

@@ -22,3 +22,8 @@ void ngraph::op::Exp::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta * shared_from_this());
 }
+
+bool ngraph::op::Exp::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/exp.hpp

@@ -54,6 +54,7 @@ namespace ngraph
 
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,
                                            const std::shared_ptr<Node>& delta) override;
+            bool is_functionally_identical(const Node&) const override;
         };
     }
 }

src/ngraph/ops/floor.hpp

@@ -51,6 +51,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Floor>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/function_call.cpp

@@ -47,8 +47,3 @@ op::FunctionCall::FunctionCall(std::shared_ptr<Function> function,
         add_output(function->get_output_element_type(i), function->get_output_shape(i));
     }
 }
-
-bool op::FunctionCall::is_functionally_identical(const Node&) const
-{
-    return false;
-}

src/ngraph/ops/function_call.hpp

@@ -55,8 +55,6 @@ namespace ngraph
                 return std::make_shared<FunctionCall>(m_function, new_args);
             }
 
-            /// \return The function to be called.
-            bool is_functionally_identical(const Node&) const override;
             /// \return A singleton vector containing the function to be called.
             std::vector<std::shared_ptr<Function>> get_functions() const override
             {

src/ngraph/ops/get_output_element.cpp

@@ -30,8 +30,3 @@ op::GetOutputElement::GetOutputElement(const std::shared_ptr<Node>& arg, size_t
 
     set_value_type_checked(arg->get_output_element_type(n), arg->get_output_shape(n));
 }
-
-bool op::GetOutputElement::is_functionally_identical(const Node& other) const
-{
-    return false;
-}

src/ngraph/ops/get_output_element.hpp

@@ -58,8 +58,6 @@ namespace ngraph
 
             /// \return The index of the tuple element to get.
             size_t get_n() const { return m_n; }
-            bool is_functionally_identical(const Node&) const override;
-
         protected:
             size_t m_n;
         };

src/ngraph/ops/greater.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Greater>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/greater_eq.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<GreaterEq>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/less.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Less>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/less_eq.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<LessEq>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/log.cpp

@@ -22,3 +22,8 @@ void ngraph::op::Log::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta / x);
 }
+
+bool ngraph::op::Log::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/log.hpp

@@ -54,6 +54,7 @@ namespace ngraph
 
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,
                                            const std::shared_ptr<Node>& delta) override;
+            bool is_functionally_identical(const Node&) const override;
         };
     }
 }

src/ngraph/ops/max_pool.cpp

@@ -150,7 +150,7 @@ op::MaxPool::MaxPool(const std::shared_ptr<Node>& arg, const Shape& window_shape
 bool op::MaxPool::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const MaxPool& rhs = dynamic_cast<const MaxPool&>(other);
         rc &= m_window_shape == rhs.m_window_shape;

src/ngraph/ops/maximum.cpp

@@ -33,3 +33,8 @@ void ngraph::op::Maximum::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(
         y, delta * make_shared<op::Convert>(make_shared<op::Greater>(y, x), y->get_element_type()));
 }
+
+bool ngraph::op::Maximum::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/maximum.hpp

@@ -53,6 +53,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Maximum>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/minimum.cpp

@@ -34,3 +34,8 @@ void ngraph::op::Minimum::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(
         y, delta * make_shared<op::Convert>(make_shared<op::Less>(y, x), y->get_element_type()));
 }
+
+bool ngraph::op::Minimum::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/minimum.hpp

@@ -53,6 +53,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Minimum>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/multiply.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Multiply::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(x, delta * y);
     adjoints.add_delta(y, x * delta);
 }
+
+bool ngraph::op::Multiply::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/multiply.hpp

@@ -53,6 +53,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Multiply>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/negative.cpp

@@ -21,3 +21,8 @@ void ngraph::op::Negative::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, -delta);
 }
+
+bool ngraph::op::Negative::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/negative.hpp

@@ -54,6 +54,7 @@ namespace ngraph
 
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,
                                            const std::shared_ptr<Node>& delta) override;
+            bool is_functionally_identical(const Node&) const override;
         };
     }
     inline std::shared_ptr<ngraph::Node> operator-(const std::shared_ptr<ngraph::Node> arg0)

src/ngraph/ops/not.cpp

@@ -34,3 +34,8 @@ op::Not::Not(const std::shared_ptr<Node>& arg)
           arg)
 {
 }
+
+bool ngraph::op::Not::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/not.hpp

@@ -48,6 +48,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Not>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
         };
     }
 }

src/ngraph/ops/not_equal.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<NotEqual>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/one_hot.cpp

@@ -45,7 +45,7 @@ op::OneHot::OneHot(const std::shared_ptr<Node>& arg, const Shape& shape, size_t
 bool op::OneHot::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const OneHot& rhs = dynamic_cast<const OneHot&>(other);
         rc &= m_shape == rhs.m_shape;

src/ngraph/ops/power.cpp

@@ -28,3 +28,8 @@ void ngraph::op::Power::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(x, delta * y * shared_from_this() / x);
     adjoints.add_delta(y, delta * shared_from_this() * log_x);
 }
+
+bool ngraph::op::Power::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/power.hpp

@@ -53,6 +53,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Power>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/reduce.cpp

@@ -90,8 +90,3 @@ op::Reduce::Reduce(const std::shared_ptr<Node>& arg_reductee,
 
     add_output(input_reductee.get_element_type(), result_shape);
 }
-
-bool op::Reduce::is_functionally_identical(const Node& other) const
-{
-    return false;
-}

src/ngraph/ops/reduce.hpp

@@ -110,8 +110,6 @@ namespace ngraph
             }
             /// \return The axis positions (0-based) to be eliminated through reduction.
             const AxisSet& get_reduction_axes() const { return m_reduction_axes; }
-            bool is_functionally_identical(const Node&) const override;
-
         protected:
             std::shared_ptr<Function> m_reduction_function;
             AxisSet m_reduction_axes;

src/ngraph/ops/remainder.hpp

@@ -55,6 +55,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Remainder>(new_args.at(0), new_args.at(1));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/replace_slice.cpp

@@ -136,7 +136,7 @@ void op::ReplaceSlice::generate_adjoints(autodiff::Adjoints& adjoints,
 bool op::ReplaceSlice::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const ReplaceSlice& slice = dynamic_cast<const ReplaceSlice&>(other);
         rc &= m_lower_bounds == slice.m_lower_bounds;

src/ngraph/ops/reshape.cpp

@@ -103,7 +103,7 @@ void op::Reshape::generate_adjoints(autodiff::Adjoints& adjoints,
 bool op::Reshape::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Reshape& reshape = dynamic_cast<const Reshape&>(other);
         rc &= m_input_order == reshape.m_input_order;

src/ngraph/ops/reverse.cpp

@@ -54,7 +54,7 @@ void op::Reverse::generate_adjoints(autodiff::Adjoints& adjoints,
 bool op::Reverse::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Reverse& obj = dynamic_cast<const Reverse&>(other);
         rc &= m_reversed_axes == obj.m_reversed_axes;

src/ngraph/ops/select.cpp

@@ -63,3 +63,8 @@ void ngraph::op::Select::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(x, delta * p_as_x_type);
     adjoints.add_delta(y, delta * not_p_as_y_type);
 }
+
+bool ngraph::op::Select::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/select.hpp

@@ -54,6 +54,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Select>(new_args.at(0), new_args.at(1), new_args.at(2));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/select_and_scatter.cpp

@@ -213,8 +213,3 @@ op::SelectAndScatter::SelectAndScatter(const std::shared_ptr<Node>& arg_selectee
     //
     set_value_type_checked(input_selectee_element_type, input_selectee_shape);
 }
-
-bool op::SelectAndScatter::is_functionally_identical(const Node& other) const
-{
-    return false;
-}

src/ngraph/ops/select_and_scatter.hpp

@@ -108,8 +108,6 @@ namespace ngraph
             const Shape& get_window_shape() const { return m_window_shape; }
             /// \return The window movement strides.
             const Strides& get_window_movement_strides() const { return m_window_movement_strides; }
-            bool is_functionally_identical(const Node&) const override;
-
         protected:
             std::shared_ptr<Function> m_selection_function;
             std::shared_ptr<Function> m_scatter_function;

src/ngraph/ops/sign.hpp

@@ -53,6 +53,10 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Sign>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node& other) const override
+            {
+                return test_identical(other);
+            }
         };
     }
 }

src/ngraph/ops/sin.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Sin::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta * (std::make_shared<op::Cos>(x)));
 }
+
+bool ngraph::op::Sin::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/sin.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Sin>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/sinh.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Sinh::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta * (std::make_shared<op::Cosh>(x)));
 }
+
+bool ngraph::op::Sinh::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/sinh.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Sinh>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/slice.cpp

@@ -101,7 +101,7 @@ void op::Slice::generate_adjoints(autodiff::Adjoints& adjoints, const std::share
 bool op::Slice::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Slice& slice = dynamic_cast<const Slice&>(other);
         rc &= m_lower_bounds == slice.m_lower_bounds;

src/ngraph/ops/sqrt.cpp

@@ -23,3 +23,8 @@ void ngraph::op::Sqrt::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta / (shared_from_this() + shared_from_this()));
 }
+
+bool ngraph::op::Sqrt::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/sqrt.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Sqrt>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/subtract.cpp

@@ -24,3 +24,8 @@ void ngraph::op::Subtract::generate_adjoints(autodiff::Adjoints& adjoints,
     adjoints.add_delta(x, delta);
     adjoints.add_delta(y, -delta);
 }
+
+bool ngraph::op::Subtract::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/subtract.hpp

@@ -56,6 +56,7 @@ namespace ngraph
 
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,
                                            const std::shared_ptr<Node>& delta) override;
+            bool is_functionally_identical(const Node&) const override;
         };
     }
     inline std::shared_ptr<ngraph::Node> operator-(const std::shared_ptr<ngraph::Node> arg0,

src/ngraph/ops/sum.cpp

@@ -64,7 +64,7 @@ void op::Sum::generate_adjoints(autodiff::Adjoints& adjoints, const std::shared_
 bool op::Sum::is_functionally_identical(const Node& other) const
 {
     bool rc = true;
-    if (Node::is_functionally_identical(other))
+    if (Node::test_identical(other))
     {
         const Sum& slice = dynamic_cast<const Sum&>(other);
         rc &= m_reduction_axes == slice.m_reduction_axes;

src/ngraph/ops/tan.cpp

@@ -26,3 +26,8 @@ void ngraph::op::Tan::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta / (c * c));
 }
+
+bool ngraph::op::Tan::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/tan.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Tan>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/tanh.cpp

@@ -26,3 +26,8 @@ void ngraph::op::Tanh::generate_adjoints(autodiff::Adjoints& adjoints,
 
     adjoints.add_delta(x, delta / (c * c));
 }
+
+bool ngraph::op::Tanh::is_functionally_identical(const Node& other) const
+{
+    return test_identical(other);
+}

src/ngraph/ops/tanh.hpp

@@ -51,6 +51,7 @@ namespace ngraph
                     throw ngraph_error("Incorrect number of new arguments");
                 return std::make_shared<Tanh>(new_args.at(0));
             }
+            bool is_functionally_identical(const Node&) const override;
 
         protected:
             virtual void generate_adjoints(autodiff::Adjoints& adjoints,

src/ngraph/ops/xla_get_tuple_element.cpp

@@ -53,8 +53,3 @@ const Nodes& op::XLAGetTupleElement::get_tuple_elements() const
 {
     return get_tuple_value()->get_tuple_elements();
 }
-
-bool op::XLAGetTupleElement::is_functionally_identical(const Node& other) const
-{
-    return false;
-}

src/ngraph/ops/xla_get_tuple_element.hpp

@@ -64,8 +64,6 @@ namespace ngraph
 
             /// \return The index of the tuple element to get.
             size_t get_n() const { return m_n; }
-            bool is_functionally_identical(const Node&) const override;
-
         protected:
             std::shared_ptr<XLANode> m_arg;
             size_t m_n;