Add inplace sort

Author: vitalsong

include/dsplib/math.h

@@ -106,6 +106,9 @@ real_t corr(span_real x, span_real y, Correlation type = Correlation::Pearson);
 //result: [sorted array, sort index]
 std::pair<arr_real, arr_int> sort(const arr_real& x, Direction dir = Direction::Ascend);
 
+//inplace sort
+void sort(inplace_real ix, Direction dir = Direction::Ascend);
+
 //determine if array is sorted
 bool issorted(span_real x, Direction dir = Direction::Ascend);
 

include/dsplib/utils.h

@@ -85,8 +85,8 @@ arr_real from_file(const std::string& file, dtype type = dtype::int16, endian or
                    long count = std::numeric_limits<long>::max());
 
 //add zeros to the end of the array
-arr_real zeropad(span_t<real_t> x, int n);
-arr_cmplx zeropad(span_t<cmplx_t> x, int n);
+arr_real zeropad(span_real x, int n);
+arr_cmplx zeropad(span_cmplx x, int n);
 
 //delays or advances the signal by the number of samples specified in delay
 //TODO: fractional delay support
@@ -111,8 +111,8 @@ base_array<T> delayseq(const base_array<T>& data, int delay) {
 }
 
 //peak localization
-real_t peakloc(const arr_real& x, int idx, bool cyclic = true);
-real_t peakloc(const arr_cmplx& x, int idx, bool cyclic = true);
+real_t peakloc(span_real x, int idx, bool cyclic = true);
+real_t peakloc(span_cmplx x, int idx, bool cyclic = true);
 
 //Estimate delay between signals
 int finddelay(span_real x1, span_real x2);

lib/math.cpp

@@ -188,6 +188,19 @@ std::pair<arr_real, arr_int> sort(const arr_real& x, Direction dir) {
     return std::make_pair(sorted, index);
 }
 
+void sort(inplace_real ix, Direction dir) {
+    auto x = ix.get();
+    if (issorted(x, dir)) {
+        return;
+    }
+
+    if (dir == Direction::Ascend) {
+        std::sort(x.begin(), x.end());
+    } else {
+        std::sort(x.begin(), x.end(), std::greater<int>());
+    }
+}
+
 bool issorted(span_real x, Direction dir) {
     if (dir == Direction::Descend) {
         auto comp = [&](auto lhs, auto rhs) {

lib/utils.cpp

@@ -161,7 +161,7 @@ arr_real from_file(const std::string& file, dtype type, endian order, long offse
 }
 
 //-------------------------------------------------------------------------------------------------
-real_t peakloc(const arr_real& x, int idx, bool cyclic) {
+real_t peakloc(span_real x, int idx, bool cyclic) {
     const int n = x.size();
     if (!cyclic && (idx == 0 || idx == n - 1)) {
         return idx;
@@ -177,7 +177,7 @@ real_t peakloc(const arr_real& x, int idx, bool cyclic) {
     return idx + q / (2 * a) - 1;
 }
 
-real_t peakloc(const arr_cmplx& x, int idx, bool cyclic) {
+real_t peakloc(span_cmplx x, int idx, bool cyclic) {
     const int n = x.size();
     if (!cyclic && (idx == 0 || idx == n - 1)) {
         return idx;
@@ -328,11 +328,11 @@ base_array<T> _zeropad(span_t<T> x, int n) {
 
 }   // namespace
 
-arr_real zeropad(span_t<real_t> x, int n) {
+arr_real zeropad(span_real x, int n) {
     return _zeropad<real_t>(x, n);
 }
 
-arr_cmplx zeropad(span_t<cmplx_t> x, int n) {
+arr_cmplx zeropad(span_cmplx x, int n) {
     return _zeropad<cmplx_t>(x, n);
 }
 

tests/math_test.cpp

@@ -442,6 +442,37 @@ TEST(MathTest, Sort) {
     }
 }
 
+//-------------------------------------------------------------------------------------------------
+TEST(MathTest, InplaceSort) {
+    {
+        arr_real x1 = {4, 1, 2, 5, 6, 7, 3, 3};
+        sort(inplace(x1));
+        ASSERT_EQ_ARR_REAL(x1, arr_real{1, 2, 3, 3, 4, 5, 6, 7});
+        ASSERT_TRUE(issorted(x1));
+    }
+    {
+        arr_real x1 = {4, 1, 2, 5, 6, 7, 3, 3};
+        sort(inplace(x1), Direction::Descend);
+        ASSERT_EQ_ARR_REAL(x1, arr_real{7, 6, 5, 4, 3, 3, 2, 1});
+        ASSERT_TRUE(issorted(x1, Direction::Descend));
+        ASSERT_FALSE(issorted(x1, Direction::Ascend));
+    }
+    {
+        arr_real x1 = {0, 1, 2, 3, 4, 5};
+        sort(inplace(x1));
+        ASSERT_EQ_ARR_REAL(x1, arr_real{0, 1, 2, 3, 4, 5});
+        ASSERT_TRUE(issorted(x1));
+        ASSERT_FALSE(issorted(x1, Direction::Descend));
+    }
+    {
+        arr_real x1 = {5, 4, 3, 2, 1, 0};
+        sort(inplace(x1), Direction::Descend);
+        ASSERT_EQ_ARR_REAL(x1, arr_real{5, 4, 3, 2, 1, 0});
+        ASSERT_TRUE(issorted(x1, Direction::Descend));
+        ASSERT_FALSE(issorted(x1, Direction::Ascend));
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 TEST(MathTest, Factor) {
     ASSERT_EQ_ARR_REAL(factor(0), arr_int{0});