[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

fastdeploy/function/sort.cc

@@ -0,0 +1,118 @@
+// 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/sort.h"
+#include "fastdeploy/function/eigen.h"
+#include "fastdeploy/function/transpose.h"
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+
+namespace fastdeploy {
+namespace function {
+
+template <typename T, typename Type>
+static void FullSort(Type input_height, Type input_width, int input_dim,
+                     const FDTensor* input, FDTensor* out, FDTensor* indices,
+                     bool descending) {
+  out->Allocate(input->Shape(), input->Dtype());
+  indices->Allocate(input->Shape(), TypeToDataType<Type>::dtype);
+
+  T* t_out = reinterpret_cast<T*>(out->Data());
+  Type* t_indices = reinterpret_cast<Type*>(indices->Data());
+
+  for (Type i = 0; i < input_height; ++i) {
+    std::vector<std::pair<T, Type>> col_vec;
+    col_vec.reserve(input_width);
+    if (input_dim == 1) {
+      auto e_input = EigenVector<T>::Flatten(*input);
+      for (Type j = 0; j < input_width; ++j) {
+        col_vec.push_back(std::pair<T, Type>(e_input(j), j));
+      }
+    } else {
+      auto e_input = EigenMatrix<T>::Reshape(*input, input_dim - 1);
+      for (Type j = 0; j < input_width; ++j) {
+        col_vec.push_back(std::pair<T, Type>(e_input(i, j), j));
+      }
+    }
+    std::sort(col_vec.begin(), col_vec.end(),
+              [&](const std::pair<T, Type>& l, const std::pair<T, Type>& r) {
+                if (descending)
+                  return (std::isnan(static_cast<double>(l.first)) &&
+                          !std::isnan(static_cast<double>(r.first))) ||
+                         (l.first > r.first);
+                else
+                  return (!std::isnan(static_cast<double>(l.first)) &&
+                          std::isnan(static_cast<double>(r.first))) ||
+                         (l.first < r.first);
+              });
+
+    for (Type j = 0; j < input_width; ++j) {
+      t_out[i * input_width + j] = col_vec[j].first;
+      t_indices[i * input_width + j] = col_vec[j].second;
+    }
+  }
+}
+
+template <typename T>
+void SortKernel(const FDTensor& x, FDTensor* out, FDTensor* indices,
+                FDDataType indices_type, bool descending, int axis) {
+  auto input_shape = x.Shape();
+  int rank = input_shape.size();
+  axis = (axis < 0) ? (rank + axis) : axis;
+  // Do full sort
+  if (axis == -1 || axis + 1 == rank) {
+    const int64_t input_width = input_shape[rank - 1];
+    const int64_t input_height = x.Numel() / input_width;
+    FD_VISIT_INT_TYPES(indices_type, "FullSort", ([&] {
+                         FullSort<T, data_t>(input_height, input_width, rank,
+                                             &x, out, indices, descending);
+                       }));
+  } else {
+    // If not full sort do transpose
+    std::vector<int64_t> trans;
+    for (int i = 0; i < axis; i++) {
+      trans.push_back(i);
+    }
+    trans.push_back(rank - 1);
+    for (int i = axis + 1; i < rank - 1; i++) {
+      trans.push_back(i);
+    }
+    trans.push_back(axis);
+
+    FDTensor trans_inp;
+    Transpose(x, &trans_inp, trans);
+    const int64_t input_width = input_shape[axis];
+    const int64_t input_height = x.Numel() / input_width;
+    FD_VISIT_INT_TYPES(indices_type, "FullSort", ([&] {
+                         FullSort<T, data_t>(input_height, input_width, rank,
+                                             &trans_inp, out, indices,
+                                             descending);
+                       }));
+    // transpose back
+    Transpose(*out, out, trans);
+    Transpose(*indices, indices, trans);
+  }
+}
+
+void Sort(const FDTensor& x, FDTensor* out, FDTensor* indices, int axis,
+          bool descending, FDDataType indices_type) {
+  FD_VISIT_INT_FLOAT_TYPES(x.dtype, "SortKernel", ([&] {
+                             SortKernel<data_t>(x, out, indices, indices_type,
+                                                descending, axis);
+                           }));
+}
+
+}  // namespace function
+}  // namespace fastdeploy