[Functions] Add quantile function (#700)

* Add sort function

* Add isfinite function

* upgrade isinf isnan

* Add Scalar to FDTensor

* Add floor, ceil function

* add cast functions

* Update out_tmp

* Update quantile

* add gather scatter along axis

* finish quantile function

* Add quantile unittest

* refresh code style for test source code

* Add comments

* Add full function

* Add scalar to fd tensor

* Add full unittest

* Add functions headers

* move fdtensor operators to fastdeploy namespace

Author: joey12300

fastdeploy/core/fd_scalar.h

@@ -0,0 +1,121 @@
+// 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 <cstdint>
+#include <limits>
+
+#include "fastdeploy/core/fd_type.h"
+#include "fastdeploy/core/float16.h"
+
+namespace fastdeploy {
+
+class Scalar {
+ public:
+  // Constructor support implicit
+  Scalar() : Scalar(0) {}
+  Scalar(double val) : dtype_(FDDataType::FP64) {  // NOLINT
+    data_.f64 = val;
+  }
+
+  Scalar(float val) : dtype_(FDDataType::FP32) {  // NOLINT
+    data_.f32 = val;
+  }
+
+  Scalar(float16 val) : dtype_(FDDataType::FP16) {  // NOLINT
+    data_.f16 = val;
+  }
+
+  Scalar(int64_t val) : dtype_(FDDataType::INT64) {  // NOLINT
+    data_.i64 = val;
+  }
+
+  Scalar(int32_t val) : dtype_(FDDataType::INT32) {  // NOLINT
+    data_.i32 = val;
+  }
+
+  Scalar(int16_t val) : dtype_(FDDataType::INT16) {  // NOLINT
+    data_.i16 = val;
+  }
+
+  Scalar(int8_t val) : dtype_(FDDataType::INT8) {  // NOLINT
+    data_.i8 = val;
+  }
+
+  Scalar(uint8_t val) : dtype_(FDDataType::UINT8) {  // NOLINT
+    data_.ui8 = val;
+  }
+
+  Scalar(bool val) : dtype_(FDDataType::BOOL) {  // NOLINT
+    data_.b = val;
+  }
+
+  // The compatible method for fliud operators,
+  // and it will be removed in the future.
+  explicit Scalar(const std::string& str_value) : dtype_(FDDataType::FP64) {
+    if (str_value == "inf") {
+      data_.f64 = std::numeric_limits<double>::infinity();
+    } else if (str_value == "-inf") {
+      data_.f64 = -std::numeric_limits<double>::infinity();
+    } else if (str_value == "nan") {
+      data_.f64 = std::numeric_limits<double>::quiet_NaN();
+    } else {
+      data_.f64 = std::stod(str_value);
+    }
+  }
+
+  template <typename RT> inline RT to() const {
+    switch (dtype_) {
+    case FDDataType::FP32:
+      return static_cast<RT>(data_.f32);
+    case FDDataType::FP64:
+      return static_cast<RT>(data_.f64);
+    case FDDataType::FP16:
+      return static_cast<RT>(data_.f16);
+    case FDDataType::INT32:
+      return static_cast<RT>(data_.i32);
+    case FDDataType::INT64:
+      return static_cast<RT>(data_.i64);
+    case FDDataType::INT16:
+      return static_cast<RT>(data_.i16);
+    case FDDataType::INT8:
+      return static_cast<RT>(data_.i8);
+    case FDDataType::UINT8:
+      return static_cast<RT>(data_.ui8);
+    case FDDataType::BOOL:
+      return static_cast<RT>(data_.b);
+    default:
+      FDASSERT(false, "Invalid enum scalar data type `%s`.",
+               Str(dtype_).c_str());
+    }
+  }
+
+  FDDataType dtype() const { return dtype_; }
+
+ private:
+  FDDataType dtype_;
+  union data {
+    bool b;
+    int8_t i8;
+    int16_t i16;
+    int32_t i32;
+    int64_t i64;
+    uint8_t ui8;
+    float16 f16;
+    float f32;
+    double f64;
+  } data_;
+};
+
+}  // namespace fastdeploy

fastdeploy/core/fd_tensor.cc

@@ -12,8 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include "fastdeploy/core/fd_tensor.h"
+#include "fastdeploy/core/fd_scalar.h"
 #include "fastdeploy/core/float16.h"
 #include "fastdeploy/utils/utils.h"
+
 #include <algorithm>
 #include <cstring>
 #ifdef WITH_GPU
@@ -344,6 +346,40 @@ void FDTensor::CopyBuffer(void* dst, const void* src, size_t nbytes,
 }
 
 FDTensor::FDTensor(const std::string& tensor_name) { name = tensor_name; }
+FDTensor::FDTensor(const char* tensor_name) { name = tensor_name; }
+
+FDTensor::FDTensor(const Scalar& scalar) {
+  Allocate({1}, scalar.dtype());
+  switch (scalar.dtype()) {
+  case FDDataType::BOOL:
+    (reinterpret_cast<bool*>(Data()))[0] = scalar.to<bool>();
+    break;
+  case FDDataType::UINT8:
+    (reinterpret_cast<uint8_t*>(Data()))[0] = scalar.to<uint8_t>();
+    break;
+  case FDDataType::INT8:
+    (reinterpret_cast<int8_t*>(Data()))[0] = scalar.to<int8_t>();
+    break;
+  case FDDataType::INT16:
+    (reinterpret_cast<int16_t*>(Data()))[0] = scalar.to<int16_t>();
+    break;
+  case FDDataType::INT32:
+    (reinterpret_cast<int*>(Data()))[0] = scalar.to<int>();
+    break;
+  case FDDataType::INT64:
+    (reinterpret_cast<int64_t*>(Data()))[0] = scalar.to<int64_t>();
+    break;
+  case FDDataType::FP16:
+    (reinterpret_cast<float16*>(Data()))[0] = scalar.to<float16>();
+    break;
+  case FDDataType::FP32:
+    (reinterpret_cast<float*>(Data()))[0] = scalar.to<float>();
+    break;
+  case FDDataType::FP64:
+    (reinterpret_cast<double*>(Data()))[0] = scalar.to<double>();
+    break;
+  }
+}
 
 FDTensor::FDTensor(const FDTensor& other)
     : shape(other.shape), name(other.name), dtype(other.dtype),

fastdeploy/core/fd_tensor.h

@@ -23,6 +23,8 @@
 
 namespace fastdeploy {
 
+struct Scalar;
+
 struct FASTDEPLOY_DECL FDTensor {
   // std::vector<int8_t> data;
   void* buffer_ = nullptr;
@@ -126,6 +128,8 @@ struct FASTDEPLOY_DECL FDTensor {
 
   FDTensor() {}
   explicit FDTensor(const std::string& tensor_name);
+  explicit FDTensor(const char* tensor_name);
+
   // Deep copy
   FDTensor(const FDTensor& other);
   // Move constructor
@@ -136,6 +140,9 @@ struct FASTDEPLOY_DECL FDTensor {
   // Move assignment
   FDTensor& operator=(FDTensor&& other);
 
+  // Scalar to FDTensor
+  explicit FDTensor(const Scalar& scalar);
+
   ~FDTensor() { FreeFn(); }
 
   static void CopyBuffer(void* dst, const void* src, size_t nbytes,

fastdeploy/function/cast.cc

@@ -0,0 +1,46 @@
+// 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.
+
+#include "fastdeploy/function/cast.h"
+#include <algorithm>
+
+namespace fastdeploy {
+namespace function {
+
+template <typename InT, typename OutT> struct CastOpTransformFunctor {
+  OutT operator()(InT in) const { return static_cast<OutT>(in); }
+};
+
+template <typename InT>
+void CastKernel(const FDTensor& x, FDTensor* out, FDDataType output_dtype) {
+
+  FD_VISIT_ALL_TYPES(output_dtype, "CastOpTransformFunctor", ([&] {
+                       auto* in_begin = reinterpret_cast<const InT*>(x.Data());
+                       auto* in_end = in_begin + x.Numel();
+                       FDTensor out_tmp;
+                       out_tmp.Allocate(x.Shape(), output_dtype);
+                       auto* out_begin = reinterpret_cast<data_t*>(out_tmp.Data());
+                       std::transform(in_begin, in_end, out_begin,
+                                      CastOpTransformFunctor<InT, data_t>());
+                       *out = std::move(out_tmp);
+                     }));
+}
+
+void Cast(const FDTensor& x, FDTensor* out, FDDataType output_dtype) {
+  FD_VISIT_ALL_TYPES(x.dtype, "CastKernel",
+                     ([&] { CastKernel<data_t>(x, out, output_dtype); }));
+}
+
+}  // namespace function
+}  // namespace fastdeploy

fastdeploy/function/cast.h

@@ -0,0 +1,31 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Cast x to output data type element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param output_dtype The type of output tensor.
+*/
+FASTDEPLOY_DECL void Cast(const FDTensor& x, FDTensor* out,
+                          FDDataType output_dtype);
+
+}  // namespace function
+}  // namespace fastdeploy

fastdeploy/function/concat.h

@@ -22,7 +22,7 @@ namespace function {
 /** Excute the concatenate operation for input FDTensor along given axis.
     @param x The input tensor.
     @param out The output tensor which stores the result.
-    @param axisi Axis which will be concatenated.
+    @param axis Axis which will be concatenated.
 */
 
 FASTDEPLOY_DECL void Concat(const std::vector<FDTensor>& x, FDTensor* out,

fastdeploy/function/elementwise.cc

@@ -32,45 +32,21 @@ void Add(const FDTensor& x, const FDTensor& y, FDTensor* out) {
                      ([&] { AddRawKernel<data_t>()(x, y, -1, out); }));
 }
 
-FDTensor operator+(const FDTensor& x, const FDTensor& y) {
-  FDTensor out;
-  Add(x, y, &out);
-  return out;
-}
-
 void Subtract(const FDTensor& x, const FDTensor& y, FDTensor* out) {
   FD_VISIT_ALL_TYPES(x.dtype, "SubtractRawKernel",
                      ([&] { SubtractRawKernel<data_t>()(x, y, -1, out); }));
 }
 
-FDTensor operator-(const FDTensor& x, const FDTensor& y) {
-  FDTensor out;
-  Subtract(x, y, &out);
-  return out;
-}
-
 void Multiply(const FDTensor& x, const FDTensor& y, FDTensor* out) {
   FD_VISIT_ALL_TYPES(x.dtype, "MultiplyRawKernel",
                      ([&] { MultiplyRawKernel<data_t>()(x, y, -1, out); }));
 }
 
-FDTensor operator*(const FDTensor& x, const FDTensor& y) {
-  FDTensor out;
-  Multiply(x, y, &out);
-  return out;
-}
-
 void Divide(const FDTensor& x, const FDTensor& y, FDTensor* out) {
   FD_VISIT_ALL_TYPES(x.dtype, "DivideRawKernel",
                      ([&] { DivideRawKernel<data_t>()(x, y, -1, out); }));
 }
 
-FDTensor operator/(const FDTensor& x, const FDTensor& y) {
-  FDTensor out;
-  Divide(x, y, &out);
-  return out;
-}
-
 template <typename T> struct MaximumRawKernel {
   void operator()(const FDTensor& x, const FDTensor& y, int axis,
                   FDTensor* out) {
@@ -85,4 +61,29 @@ void Maximum(const FDTensor& x, const FDTensor& y, FDTensor* out) {
 }
 
 }  // namespace function
+
+FDTensor operator+(const FDTensor& x, const FDTensor& y) {
+  FDTensor out;
+  function::Add(x, y, &out);
+  return out;
+}
+
+FDTensor operator-(const FDTensor& x, const FDTensor& y) {
+  FDTensor out;
+  function::Subtract(x, y, &out);
+  return out;
+}
+
+FDTensor operator*(const FDTensor& x, const FDTensor& y) {
+  FDTensor out;
+  function::Multiply(x, y, &out);
+  return out;
+}
+
+FDTensor operator/(const FDTensor& x, const FDTensor& y) {
+  FDTensor out;
+  function::Divide(x, y, &out);
+  return out;
+}
+
 }  // namespace fastdeploy