[Functions] Add +-*/ operators and reshape for FDTensor (#655)

* Add +-*/ functions

* Add same dims test case for operations

* add broadcast 0

* Add broadcast dim2 testcase

* Add broadcast dim3 and dim4 testcase

* Add +-*/ operators

* Add mixed operation

* refresh code style

* Add reshape op

* update code style

fastdeploy/function/elementwise_functor.h

@@ -0,0 +1,126 @@
+// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "fastdeploy/function/eigen.h"
+#include "fastdeploy/function/elementwise.h"
+#include "fastdeploy/function/elementwise_base.h"
+#include <algorithm>
+
+namespace fastdeploy {
+namespace function {
+
+template <typename Functor> struct SameDimsElementwiseCompute {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    z->Allocate(x.Shape(), x.Dtype());
+    Functor()(x, y, z);
+  }
+};
+
+template <typename T> struct SameDimsAddFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x + eigen_y;
+  }
+};
+
+template <typename T> struct SameDimsSubtractFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x - eigen_y;
+  }
+};
+
+template <typename T> struct SameDimsMultiplyFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x * eigen_y;
+  }
+};
+
+template <typename T> struct SameDimsDivideFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x / eigen_y;
+  }
+};
+
+// Add
+template <typename T> struct AddFunctor {
+  inline T operator()(const T a, const T b) const { return a + b; }
+};
+template <typename T> struct InverseAddFunctor {
+  inline T operator()(const T a, const T b) const { return b + a; }
+};
+
+// Subtract
+template <typename T> struct SubtractFunctor {
+  inline T operator()(const T a, const T b) const { return a - b; }
+};
+template <typename T> struct InverseSubtractFunctor {
+  inline T operator()(const T a, const T b) const { return b - a; }
+};
+
+// Multiply
+template <typename T> struct MultiplyFunctor {
+  inline T operator()(const T a, const T b) const { return a * b; }
+};
+template <> struct MultiplyFunctor<bool> {
+  inline bool operator()(const bool a, const bool b) const { return a && b; }
+};
+template <typename T> struct InverseMultiplyFunctor {
+  inline T operator()(const T a, const T b) const { return b * a; }
+};
+template <> struct InverseMultiplyFunctor<bool> {
+  inline bool operator()(const bool a, const bool b) const { return b && a; }
+};
+
+// Divide
+#define DIV_ERROR_INFO                                                         \
+  "InvalidArgumentError: Integer division by zero encountered in "             \
+  "(floor) divide. Please check the input value."
+
+template <typename T, typename Enable = void> struct DivideFunctor {
+  inline T operator()(const T a, const T b) const { return a / b; }
+};
+
+template <typename T>
+struct DivideFunctor<
+    T, typename std::enable_if<std::is_integral<T>::value>::type> {
+  inline T operator()(const T a, const T b) const {
+    // For int32/int64, need to check whether the divison is zero.
+    FDASSERT(b != 0, DIV_ERROR_INFO);
+    return a / b;
+  }
+};
+
+template <typename T, typename Enable = void> struct InverseDivideFunctor {
+  inline T operator()(const T a, const T b) const { return b / a; }
+};
+
+}  // namespace function
+}  // namespace fastdeploy