inplace span support

Use `inplace' to explicitly specify calculations on the input data.

- Add `inplace_span_t<T>` class;
- Add `inplace` function;
- Add some inplace functions;
- Add inplace version of `solve` for `FftPlanC`;
- Code refactoring;

Author: vitalsong

include/dsplib/fft.h

@@ -23,6 +23,14 @@ class FftPlanC
      */
     virtual void solve(span_t<cmplx_t> x, mut_span_t<cmplx_t> r) const = 0;
 
+    //inplace FFT implementation
+    virtual void solve(inplace_cmplx inp) const {
+        //default non optimal implementation with temp array
+        auto x = inp.get();
+        const auto y = this->solve(x);
+        x.assign(y);
+    }
+
     [[nodiscard]] virtual int size() const noexcept = 0;
 };
 

include/dsplib/iterator.h

@@ -55,14 +55,6 @@ struct SliceIterator
         return lhs.ptr_ != rhs.ptr_;
     };
 
-    friend bool operator>(const SliceIterator& lhs, const SliceIterator& rhs) noexcept {
-        return lhs.ptr_ > rhs.ptr_;
-    };
-
-    friend bool operator<(const SliceIterator& lhs, const SliceIterator& rhs) noexcept {
-        return lhs.ptr_ < rhs.ptr_;
-    };
-
 private:
     pointer ptr_;
     int step_{1};

include/dsplib/math.h

@@ -7,6 +7,8 @@
 
 namespace dsplib {
 
+//TODO: mark noexcept
+
 //exponential
 arr_real exp(const arr_real& arr);
 real_t exp(real_t v);
@@ -53,20 +55,23 @@ int argmin(span_real arr);
 int argmin(span_cmplx arr);
 
 //absolute value and complex magnitude
-arr_real abs(const arr_real& arr);
-real_t abs(real_t v);
-arr_real abs(const arr_cmplx& arr);
-real_t abs(cmplx_t v);
+arr_real abs(const arr_real& arr) noexcept;
+real_t abs(real_t v) noexcept;
+arr_real abs(const arr_cmplx& arr) noexcept;
+real_t abs(cmplx_t v) noexcept;
+void abs(inplace_real arr) noexcept;
 
 //phase angle in the interval [-pi, pi] for each element of a complex array z
 arr_real angle(const arr_cmplx& arr);
 real_t angle(cmplx_t v);
 
 //round
-real_t round(const real_t& x);
-cmplx_t round(const cmplx_t& x);
-arr_real round(const arr_real& arr);
-arr_cmplx round(const arr_cmplx& arr);
+real_t round(const real_t& x) noexcept;
+cmplx_t round(const cmplx_t& x) noexcept;
+arr_real round(const arr_real& arr) noexcept;
+arr_cmplx round(const arr_cmplx& arr) noexcept;
+void round(inplace_real arr) noexcept;
+void round(inplace_cmplx arr) noexcept;
 
 //array sum
 real_t sum(const arr_real& arr);
@@ -181,8 +186,9 @@ arr_cmplx power(const arr_cmplx& x, int n);
 
 //square root (only positive values)
 //TODO: add complex result for negative or complex input
-real_t sqrt(real_t x);
-arr_real sqrt(const arr_real& x);
+real_t sqrt(real_t x) noexcept;
+arr_real sqrt(const arr_real& arr) noexcept;
+void sqrt(inplace_real arr) noexcept;
 
 //array log
 arr_real log(const arr_real& arr);
@@ -210,7 +216,7 @@ arr_real upsample(const arr_real& arr, int n, int phase = 0);
 arr_cmplx upsample(const arr_cmplx& arr, int n, int phase = 0);
 
 //abs(x)^2
-arr_real abs2(const arr_cmplx& x);
+arr_real abs2(const arr_cmplx& x) noexcept;
 
 constexpr real_t abs2(const cmplx_t& x) noexcept {
     return x.abs2();
@@ -269,16 +275,20 @@ inline cmplx_t sign(const cmplx_t& x) noexcept {
 
 //----------------------------------------------------------------------------------------
 //convert power <-> decibels: db = 10 * log10(pow)
-real_t pow2db(real_t v);
-arr_real pow2db(const arr_real& v);
-real_t db2pow(real_t v);
-arr_real db2pow(const arr_real& v);
+real_t pow2db(real_t v) noexcept;
+arr_real pow2db(const arr_real& arr) noexcept;
+real_t db2pow(real_t v) noexcept;
+arr_real db2pow(const arr_real& arr) noexcept;
+void pow2db(inplace_real arr) noexcept;
+void db2pow(inplace_real arr) noexcept;
 
 //convert magnitude <-> decibels: db = 20 * log10(mag)
-real_t mag2db(real_t v);
-arr_real mag2db(const arr_real& v);
-real_t db2mag(real_t v);
-arr_real db2mag(const arr_real& v);
+real_t mag2db(real_t v) noexcept;
+arr_real mag2db(const arr_real& arr) noexcept;
+real_t db2mag(real_t v) noexcept;
+arr_real db2mag(const arr_real& arr) noexcept;
+void mag2db(inplace_real arr) noexcept;
+void db2mag(inplace_real arr) noexcept;
 
 //----------------------------------------------------------------------------------------
 //check that the number is prime

include/dsplib/slice.h

@@ -120,17 +120,17 @@ class mut_slice_t
     }
 
     mut_slice_t& operator=(const slice_t<T>& rhs) {
-        this->copy(*this, rhs);
+        this->assign(rhs);
         return *this;
     }
 
     mut_slice_t& operator=(const mut_slice_t<T>& rhs) {
-        *this = slice_t<T>(rhs);
+        this->assign(slice_t<T>(rhs));
         return *this;
     }
 
     mut_slice_t& operator=(const base_array<T>& rhs) {
-        DSPLIB_ASSERT(!is_same_memory(rhs.slice(0, rhs.size()), *this), "Assigned array to same slice");
+        DSPLIB_ASSERT(!is_same_memory(rhs.slice(0, rhs.size())), "Assigned array to same slice");
         *this = rhs.slice(0, rhs.size());
         return *this;
     }
@@ -165,19 +165,42 @@ class mut_slice_t
         return current;
     }
 
+    //TODO: replace to `copy` or `to_arr` function
     base_array<T> operator*() const noexcept {
         return base_array<T>(*this);
     }
 
-    static bool is_same_memory(slice_t<T> r1, slice_t<T> r2) noexcept {
-        if (r1.empty() || r2.empty()) {
-            return false;
+    void assign(slice_t<T> rhs) {
+        DSPLIB_ASSERT(size() == rhs.size(), "Slices size must be equal");
+        const int count = size();
+
+        //empty slice assign
+        if (count == 0) {
+            return;
         }
-        auto start1 = r1.begin();
-        auto end1 = r1.end();
-        auto start2 = r2.begin();
-        auto end2 = r2.end();
-        return (start1 < end2) && (start2 < end1);
+
+        //simple block copy/move (optimization)
+        const bool is_same = is_same_memory(rhs);
+
+        //check all slices is span
+        if ((stride() == 1) && (rhs.stride() == 1)) {
+            const auto* src = rhs.data_;
+            auto* dst = data_;
+            if (!is_same) {
+                std::memcpy(dst, src, count * sizeof(*src));
+            } else {
+                std::memmove(dst, src, count * sizeof(*src));
+            }
+            return;
+        }
+
+        //same array, specific indexing
+        if (is_same) {
+            *this = base_array<T>(rhs);
+            return;
+        }
+
+        std::copy(rhs.begin(), rhs.end(), begin());
     }
 
     static mut_slice_t make_slice(T* data, int size, int i1, int i2, int step) {
@@ -202,38 +225,6 @@ class mut_slice_t
         return mut_slice_t(data + i1, step, count);
     }
 
-    static void copy(mut_slice_t<T> lhs, slice_t<T> rhs) {
-        DSPLIB_ASSERT(lhs.size() == rhs.size(), "Slices size must be equal");
-        const int count = lhs.size();
-
-        //empty slice assign
-        if (count == 0) {
-            return;
-        }
-
-        //simple block copy/move (optimization)
-        const bool is_same = is_same_memory(rhs, slice_t(lhs));
-        if ((lhs.stride() == 1) && (rhs.stride() == 1)) {
-            const auto* src = &(*rhs.begin());
-            auto* dst = &(*lhs.begin());
-            if (!is_same) {
-                std::memcpy(dst, src, count * sizeof(*src));
-            } else {
-                //overlapped
-                std::memmove(dst, src, count * sizeof(*src));
-            }
-            return;
-        }
-
-        //same array, specific indexing
-        if (is_same) {
-            lhs = base_array<T>(rhs);
-            return;
-        }
-
-        std::copy(rhs.begin(), rhs.end(), lhs.begin());
-    }
-
 protected:
     explicit mut_slice_t(T* data, int stride, int count)
       : data_{data}
@@ -242,6 +233,25 @@ class mut_slice_t
         DSPLIB_ASSERT(count >= 0, "Count of elements must be positive");
     }
 
+    bool is_same_memory(slice_t<T> rhs) noexcept {
+        if (empty() || rhs.empty()) {
+            return false;
+        }
+        auto start1 = rhs.data_;
+        auto end1 = start1 + (rhs.count_ * rhs.stride_);
+        if (start1 > end1) {
+            std::swap(start1, end1);
+        }
+
+        auto start2 = data_;
+        auto end2 = start2 + (count_ * stride_);
+        if (start2 > end2) {
+            std::swap(start2, end2);
+        }
+
+        return (start1 < end2) && (start2 < end1);
+    }
+
     T* data_{nullptr};
     int stride_{0};
     int count_{0};

include/dsplib/span.h

@@ -68,7 +68,12 @@ class mut_span_t : public mut_slice_t<T>
         if (this == &rhs) {
             return *this;
         }
-        mut_slice_t<T>::operator=(slice_t<T>(rhs));
+        this->assign(rhs);
+        return *this;
+    }
+
+    mut_span_t& operator=(const span_t<T>& rhs) {
+        this->assign(rhs);
         return *this;
     }
 
@@ -84,7 +89,7 @@ class mut_span_t : public mut_slice_t<T>
     }
 
     mut_span_t& operator=(const base_array<T>& rhs) {
-        *this = span_t<T>(rhs.data(), rhs.size());
+        this->assign(rhs);
         return *this;
     }
 
@@ -117,12 +122,33 @@ class mut_span_t : public mut_slice_t<T>
         return this->data_ + this->count_;
     }
 
+    void assign(span_t<T> rhs) {
+        DSPLIB_ASSERT(this->size() == rhs.size(), "Span size is not equal");
+        if (!is_same_memory(rhs)) {
+            std::memcpy(this->data(), rhs.data(), size() * sizeof(T));
+        } else {
+            std::memmove(this->data(), rhs.data(), size() * sizeof(T));
+        }
+    }
+
     //TODO: add more checks
     mut_span_t slice(int i1, int i2) const {
         DSPLIB_ASSERT((i1 >= 0) && (i1 < this->count_), "invalid range");
         DSPLIB_ASSERT((i2 > i1) && (i2 <= this->count_), "invalid range");
         return mut_span_t(this->data_ + i1, (i2 - i1));
     }
+
+private:
+    bool is_same_memory(span_t<T> rhs) noexcept {
+        if (this->size() == 0 || rhs.size() == 0) {
+            return false;
+        }
+        auto start1 = this->data();
+        auto end1 = start1 + this->size();
+        auto start2 = rhs.data();
+        auto end2 = start2 + rhs.size();
+        return (start1 < end2) && (start2 < end1);
+    }
 };
 
 //immutable span
@@ -216,4 +242,38 @@ mut_span_t<T> make_span(base_array<T>& x) noexcept {
 using span_real = span_t<real_t>;
 using span_cmplx = span_t<cmplx_t>;
 
+template<typename T>
+class inplace_span_t
+{
+public:
+    explicit inplace_span_t(mut_span_t<T> v) noexcept
+      : d_{std::move(v)} {
+    }
+
+    mut_span_t<T> get() noexcept {
+        return d_;
+    }
+
+private:
+    mut_span_t<T> d_;
+};
+
+template<typename T>
+inplace_span_t<T> inplace(base_array<T>& x) {
+    return inplace_span_t(make_span(x));
+}
+
+template<typename T>
+inplace_span_t<T> inplace(std::vector<T>& x) {
+    return inplace_span_t(make_span(x));
+}
+
+template<typename T>
+inplace_span_t<T> inplace(mut_span_t<T> x) {
+    return inplace_span_t(x);
+}
+
+using inplace_real = inplace_span_t<real_t>;
+using inplace_cmplx = inplace_span_t<cmplx_t>;
+
 }   // namespace dsplib

lib/fft/fact-fft.cpp

@@ -131,9 +131,7 @@ void _facfft(const PlanTree* plan, cmplx_t* restrict x, cmplx_t* restrict mem, c
     const int n = plan->size();
 
     if (!plan->has_next()) {
-        //TODO: inplace fft
-        plan->solver()->solve(make_span(x, n), make_span(mem, n));
-        std::memcpy(x, mem, n * sizeof(cmplx_t));
+        plan->solver()->solve(inplace(make_span(x, n)));
         return;
     }
 
@@ -188,11 +186,16 @@ FactorFFTPlan::FactorFFTPlan(int n)
 }
 
 void FactorFFTPlan::solve(span_t<cmplx_t> x, mut_span_t<cmplx_t> r) const {
-    DSPLIB_ASSERT(x.size() == _n, "input array size is not equal fft size");
     DSPLIB_ASSERT(x.size() == r.size(), "output array size error");
+    r.assign(x);
+    this->solve(inplace(r));
+}
+
+void FactorFFTPlan::solve(inplace_span_t<cmplx_t> r) const {
+    auto x = r.get();
+    DSPLIB_ASSERT(x.size() == _n, "input array size is not equal fft size");
     arr_cmplx tmp(_n);
-    r = x;   //TODO: remove copy
-    _facfft(_plan.get(), r.data(), tmp.data(), _twiddle.data(), _n);
+    _facfft(_plan.get(), x.data(), tmp.data(), _twiddle.data(), _n);
 }
 
 [[nodiscard]] int FactorFFTPlan::size() const noexcept {

lib/fft/fact-fft.h

@@ -18,6 +18,7 @@ class FactorFFTPlan : public FftPlanC
 
     [[nodiscard]] arr_cmplx solve(span_t<cmplx_t> x) const final;
     void solve(span_t<cmplx_t> x, mut_span_t<cmplx_t> r) const final;
+    void solve(inplace_span_t<cmplx_t> r) const final;
     [[nodiscard]] int size() const noexcept final;
 
 private: