Rebase fixes. Remove operator(int i).

vitalsong · vitalsong · commit 52fd89b5d94a · 2025-04-23T17:10:31.000+03:00
diff --git a/include/dsplib/array.h b/include/dsplib/array.h
@@ -9,6 +9,7 @@
 #include <dsplib/slice.h>
 #include <dsplib/indexing.h>
 #include <dsplib/assert.h>
+#include <dsplib/span.h>
 
 namespace dsplib {
 
@@ -25,8 +26,8 @@ using ResultType = conditional_t<std::is_same_v<T1, cmplx_t> || std::is_same_v<T
 
 template<typename T_dst, typename T_src>
 base_array<T_dst> array_cast(const base_array<T_src>& src) noexcept {
-    static_assert(is_scalar_v<T_src> && is_scalar_v<T_dst>, "types must be scalar");
-    static_assert(!(is_complex_v<T_src> && !is_complex_v<T_dst>), "complex to real cast is not allowed");
+    static_assert(is_scalar_v<T_src> && is_scalar_v<T_dst>, "Types must be scalar");
+    static_assert(!(is_complex_v<T_src> && !is_complex_v<T_dst>), "Complex to real cast is not allowed");
     if constexpr (std::is_same_v<T_src, T_dst>) {
         return src;
     } else if constexpr (!is_complex_v<T_src> && is_complex_v<T_dst>) {
@@ -71,24 +72,6 @@ constexpr bool is_array_convertible() noexcept {
     return true;
 }
 
-template<typename T_dst, typename T_src>
-base_array<T_dst> array_cast(const base_array<T_src>& src) noexcept {
-    static_assert(is_scalar_v<T_src> && is_scalar_v<T_dst>, "Types must be scalar");
-    static_assert(!(is_complex_v<T_src> && !is_complex_v<T_dst>), "Complex to Real cast is not allowed");
-
-    if constexpr (std::is_same_v<T_src, T_dst>) {
-        return src;
-    } else if constexpr (!is_complex_v<T_src> && is_complex_v<T_dst>) {
-        base_array<T_dst> dst(src.size());
-        for (int i = 0; i < src.size(); ++i) {
-            dst[i].re = static_cast<real_t>(src[i]);
-        }
-        return dst;
-    } else {
-        return base_array<T_dst>(src);
-    }
-}
-
 //rules for implicit array conversion
 //TODO: use static_assert and verbose error message
 template<typename T_src, typename T_dst>
@@ -322,16 +305,6 @@ class base_array
         return r;
     }
 
-    //--------------------------------------------------------------------
-    //TODO: remove
-    const T& operator()(int i) const noexcept {
-        return this->operator[](i);
-    }
-
-    T& operator()(int i) noexcept {
-        return this->operator[](i);
-    }
-
     //--------------------------------------------------------------------
     slice_t<T> slice(int i1, int i2, int m) {
         return slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
diff --git a/include/dsplib/czt.h b/include/dsplib/czt.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "dsplib/types.h"
 #include <dsplib/fft.h>
 #include <memory>
 
diff --git a/include/dsplib/fft.h b/include/dsplib/fft.h
@@ -13,14 +13,7 @@ class FftPlanC
 {
 public:
     virtual ~FftPlanC() = default;
-
-    [[nodiscard]] virtual arr_cmplx solve(const arr_cmplx& x) const = 0;
-
-    [[deprecated]] virtual void solve(const cmplx_t* x, cmplx_t* y, int n) const {
-        const auto r = this->solve(arr_cmplx(x, n));
-        std::memcpy(y, r.data(), n * sizeof(cmplx_t));
-    }
-
+    [[nodiscard]] virtual arr_cmplx solve(span_t<cmplx_t> x) const = 0;
     [[nodiscard]] virtual int size() const noexcept = 0;
 };
 
@@ -31,15 +24,7 @@ class FftPlanR
 {
 public:
     virtual ~FftPlanR() = default;
-
-    [[nodiscard]] virtual arr_cmplx solve(const arr_real& x) const = 0;
-
-    [[deprecated]] virtual void solve(const real_t* x, cmplx_t* y, int n) const {
-        //TODO: use span
-        const auto r = this->solve(arr_real(x, n));
-        std::memcpy(y, r.data(), n * sizeof(cmplx_t));
-    }
-
+    [[nodiscard]] virtual arr_cmplx solve(span_t<real_t> x) const = 0;
     [[nodiscard]] virtual int size() const noexcept = 0;
 };
 
@@ -72,7 +57,7 @@ arr_cmplx fft(span_t<cmplx_t> x, int n);
 arr_cmplx fft(span_t<real_t> x);
 arr_cmplx fft(span_t<real_t> x, int n);
 
-arr_cmplx rfft(const arr_real& x);          // equal `fft(x)`
-arr_cmplx rfft(const arr_real& x, int n);   // equal `fft(x, n)`
+arr_cmplx rfft(span_t<real_t> x);          // equal `fft(x)`
+arr_cmplx rfft(span_t<real_t> x, int n);   // equal `fft(x, n)`
 
 }   // namespace dsplib
diff --git a/include/dsplib/ifft.h b/include/dsplib/ifft.h
@@ -15,7 +15,7 @@ class IfftPlanR
 {
 public:
     virtual ~IfftPlanR() = default;
-    [[nodiscard]] virtual arr_real solve(const arr_cmplx& x) const = 0;
+    [[nodiscard]] virtual arr_real solve(span_t<cmplx_t> x) const = 0;
     [[nodiscard]] virtual int size() const noexcept = 0;
 };
 
@@ -37,16 +37,16 @@ std::shared_ptr<IfftPlanR> ifft_plan_r(int n);
  * @param x Input array [N]
  * @return Result array [N]
  */
-arr_cmplx ifft(const arr_cmplx& x);
+arr_cmplx ifft(span_t<cmplx_t> x);
 
 /**
  * @brief Inverse real fourier transform
  * @param x Input array [N or N/2+1]
  * @param n Transform size
  * @return Result array [N]
  */
-arr_real irfft(const arr_cmplx& x, int n);
+arr_real irfft(span_t<cmplx_t> x, int n);
 
-arr_real irfft(const arr_cmplx& x);
+arr_real irfft(span_t<cmplx_t> x);
 
 }   // namespace dsplib
diff --git a/include/dsplib/lms.h b/include/dsplib/lms.h
@@ -46,8 +46,8 @@ class LmsFilter
         }
 
         int nx = x.size();
-        base_array<T> y = array_cast<T>(zeros(nx));
-        base_array<T> e = array_cast<T>(zeros(nx));
+        base_array<T> y(nx);
+        base_array<T> e(nx);
         base_array<T> tu = _u | x;
         arr_real tu2 = (_method == LmsType::NLMS) ? abs2(tu) : arr_real{};
 
diff --git a/include/dsplib/span.h b/include/dsplib/span.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <dsplib/throw.h>
+#include <dsplib/assert.h>
 #include <dsplib/types.h>
 #include <dsplib/slice.h>
 
@@ -56,11 +56,6 @@ class mut_span_t : public slice_t<T>
         return _len;
     }
 
-    T& operator()(int i) noexcept {
-        assert((i >= 0) && (i < _len));
-        return _ptr[i];
-    }
-
     T& operator[](int i) noexcept {
         assert((i >= 0) && (i < _len));
         return _ptr[i];
@@ -159,11 +154,6 @@ class span_t : public const_slice_t<T>
         return _len;
     }
 
-    const T& operator()(int i) const noexcept {
-        assert((i >= 0) && (i < _len));
-        return _ptr[i];
-    }
-
     const T& operator[](int i) const noexcept {
         assert((i >= 0) && (i < _len));
         return _ptr[i];
diff --git a/lib/fft.cpp b/lib/fft.cpp
@@ -4,12 +4,12 @@
 
 namespace dsplib {
 
-arr_cmplx fft(const arr_cmplx& x) {
+arr_cmplx fft(span_t<cmplx_t> x) {
     auto plan = fft_plan_c(x.size());
     return plan->solve(x);
 }
 
-arr_cmplx fft(const arr_cmplx& x, int n) {
+arr_cmplx fft(span_t<cmplx_t> x, int n) {
     if (n == x.size()) {
         return fft(x);
     }
@@ -19,12 +19,12 @@ arr_cmplx fft(const arr_cmplx& x, int n) {
     return fft(x.slice(0, n));
 }
 
-arr_cmplx fft(const arr_real& x) {
+arr_cmplx fft(span_t<real_t> x) {
     auto plan = fft_plan_r(x.size());
     return plan->solve(x);
 }
 
-arr_cmplx fft(const arr_real& x, int n) {
+arr_cmplx fft(span_t<real_t> x, int n) {
     if (n == x.size()) {
         return fft(x);
     }
@@ -34,11 +34,11 @@ arr_cmplx fft(const arr_real& x, int n) {
     return fft(x.slice(0, n));
 }
 
-arr_cmplx rfft(const arr_real& x) {
+arr_cmplx rfft(span_t<real_t> x) {
     return fft(x);
 }
 
-arr_cmplx rfft(const arr_real& x, int n) {
+arr_cmplx rfft(span_t<real_t> x, int n) {
     return fft(x, n);
 }
 
diff --git a/lib/fft/cmplx-ifft.h b/lib/fft/cmplx-ifft.h
@@ -11,9 +11,10 @@ class CmplxIfftPlan : public IfftPlanC
       : fft_{fft_plan_c(n)} {
     }
 
-    arr_cmplx solve(const arr_cmplx& x) const final {
+    arr_cmplx solve(span_t<cmplx_t> x) const final {
         const real_t m = real_t(1) / x.size();
-        arr_cmplx y = x * m;
+        arr_cmplx y(x);
+        y *= m;
         _inplace_conj(y);
         y = fft_->solve(y);
         _inplace_conj(y);
diff --git a/lib/fft/fact-fft.cpp b/lib/fft/fact-fft.cpp
@@ -131,9 +131,11 @@ void _facfft(const PlanTree* plan, cmplx_t* restrict x, cmplx_t* restrict mem, c
     const int n = plan->size();
 
     if (!plan->has_next()) {
-        //TODO: span
-        plan->solver()->solve(x, mem, n);
-        std::memcpy(x, mem, n * sizeof(cmplx_t));
+        //TODO: plan->solver()->solve(x, mem, n);
+        // std::memcpy(x, mem, n * sizeof(cmplx_t));
+        //TODO: inplace fft
+        const auto y = plan->solver()->solve(span(x, n));
+        std::memcpy(x, y.data(), n * sizeof(cmplx_t));
         return;
     }
 
diff --git a/lib/fft/pow2-fft.cpp b/lib/fft/pow2-fft.cpp
@@ -73,15 +73,10 @@ Pow2FftPlan::Pow2FftPlan(int n)
 
 arr_cmplx Pow2FftPlan::solve(span_t<cmplx_t> x) const {
     arr_cmplx y(x.size());
-    this->solve(x, y);
+    _fft(x.data(), y.data(), n_);
     return y;
 }
 
-void Pow2FftPlan::solve(const cmplx_t* x, cmplx_t* y, int n) const {
-    DSPLIB_ASSERT(x != y, "Pointers must be restricted");
-    _fft(x, y, n);
-}
-
 int Pow2FftPlan::size() const noexcept {
     return n_;
 }
diff --git a/lib/fft/pow2-fft.h b/lib/fft/pow2-fft.h
@@ -10,11 +10,7 @@ class Pow2FftPlan : public FftPlanC
 {
 public:
     explicit Pow2FftPlan(int n);
-
     [[nodiscard]] arr_cmplx solve(span_t<cmplx_t> x) const final;
-
-    void solve(span_t<cmplx_t> x, mut_span_t<cmplx_t> y) const final;
-
     [[nodiscard]] int size() const noexcept final;
 
 private:
diff --git a/lib/fft/primes-fft.h b/lib/fft/primes-fft.h
@@ -3,6 +3,8 @@
 #include "dsplib/czt.h"
 #include "dsplib/fft.h"
 #include "dsplib/math.h"
+#include "dsplib/span.h"
+#include "dsplib/utils.h"
 
 #include <cassert>
 #include <cstring>
@@ -28,7 +30,7 @@ class PrimesFftC : public FftPlanC
         }
     }
 
-    [[nodiscard]] arr_cmplx solve(const arr_cmplx& x) const final {
+    [[nodiscard]] arr_cmplx solve(span_t<cmplx_t> x) const final {
         arr_cmplx y(x.size());
         _dft(x.data(), y.data(), y.size());
         return y;
@@ -38,11 +40,6 @@ class PrimesFftC : public FftPlanC
         return n_;
     }
 
-    void solve(const cmplx_t* restrict x, cmplx_t* restrict y, int n) const final {
-        DSPLIB_ASSERT(x != y, "Pointers must be restricted");
-        _dft(x, y, n);
-    }
-
 private:
     //TODO: add dft5, dft7
 
@@ -78,7 +75,7 @@ class PrimesFftC : public FftPlanC
             //TODO: noexcept?
             //TODO: call without copy
             assert(czt_ && czt_->size() == n);
-            const auto r = czt_->solve(complex(x, n));
+            const auto r = czt_->solve(span(x, n));
             std::memcpy(y, r.data(), n * sizeof(cmplx_t));
         }
     }
diff --git a/lib/fft/real-fft.cpp b/lib/fft/real-fft.cpp
@@ -13,12 +13,12 @@ RealFftPlan::RealFftPlan(int n)
     DSPLIB_ASSERT(n % 2 == 0, "FFT size must be even");
 }
 
-arr_cmplx RealFftPlan::solve(const arr_real& x) const {
+arr_cmplx RealFftPlan::solve(span_t<real_t> x) const {
     using namespace std::complex_literals;
     DSPLIB_ASSERT(x.size() == n_, "Input size must be equal FFT size");
     const int n2 = n_ / 2;
 
-    arr_cmplx z(reinterpret_cast<const cmplx_t*>(x.data()), n2);
+    arr_cmplx z(span(reinterpret_cast<const cmplx_t*>(x.data()), n2));
     const auto Z = fft_->solve(z * 0.5);
 
     arr_cmplx res(n_);
diff --git a/lib/fft/real-fft.h b/lib/fft/real-fft.h
@@ -8,7 +8,7 @@ class RealFftPlan : public FftPlanR
 {
 public:
     explicit RealFftPlan(int n);
-    [[nodiscard]] arr_cmplx solve(const arr_real& x) const final;
+    [[nodiscard]] arr_cmplx solve(span_t<real_t> x) const final;
     [[nodiscard]] int size() const noexcept final;
 
 private:
diff --git a/lib/fft/real-ifft.cpp b/lib/fft/real-ifft.cpp
@@ -31,7 +31,7 @@ RealIfftPlan::RealIfftPlan(int n)
     DSPLIB_ASSERT(n % 2 == 0, "ifft size must be even");
 }
 
-arr_real RealIfftPlan::solve(const arr_cmplx& x) const {
+arr_real RealIfftPlan::solve(span_t<cmplx_t> x) const {
     assert(n_ % 2 == 0);
     DSPLIB_ASSERT((x.size() == n_) || (x.size() == n_ / 2 + 1), "input size must be n/2+1 or n");
 
diff --git a/lib/fft/real-ifft.h b/lib/fft/real-ifft.h
@@ -9,7 +9,7 @@ class RealIfftPlan : public IfftPlanR
 {
 public:
     explicit RealIfftPlan(int n);
-    [[nodiscard]] arr_real solve(const arr_cmplx& x) const final;
+    [[nodiscard]] arr_real solve(span_t<cmplx_t>) const final;
     [[nodiscard]] int size() const noexcept final;
 
 private:
diff --git a/lib/fft/small-fft.h b/lib/fft/small-fft.h
diff --git a/lib/fir.cpp b/lib/fir.cpp
diff --git a/lib/ifft.cpp b/lib/ifft.cpp
diff --git a/tests/arr_cmpl_test.cpp b/tests/arr_cmpl_test.cpp
diff --git a/tests/math_test.cpp b/tests/math_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -46,8 +46,8 @@ class LmsFilter`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`int nx = x.size();`
`49`		`- base_array<T> y = array_cast<T>(zeros(nx));`
`50`		`- base_array<T> e = array_cast<T>(zeros(nx));`
	`49`	`+ base_array<T> y(nx);`
	`50`	`+ base_array<T> e(nx);`
`51`	`51`	`base_array<T> tu = _u \| x;`
`52`	`52`	`arr_real tu2 = (_method == LmsType::NLMS) ? abs2(tu) : arr_real{};`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -4,12 +4,12 @@`
`4`	`4`
`5`	`5`	`namespace dsplib {`
`6`	`6`
`7`		`-arr_cmplx fft(const arr_cmplx& x) {`
	`7`	`+arr_cmplx fft(span_t<cmplx_t> x) {`
`8`	`8`	`auto plan = fft_plan_c(x.size());`
`9`	`9`	`return plan->solve(x);`
`10`	`10`	`}`
`11`	`11`
`12`		`-arr_cmplx fft(const arr_cmplx& x, int n) {`
	`12`	`+arr_cmplx fft(span_t<cmplx_t> x, int n) {`
`13`	`13`	`if (n == x.size()) {`
`14`	`14`	`return fft(x);`
`15`	`15`	`}`
`@@ -19,12 +19,12 @@ arr_cmplx fft(const arr_cmplx& x, int n) {`
`19`	`19`	`return fft(x.slice(0, n));`
`20`	`20`	`}`
`21`	`21`
`22`		`-arr_cmplx fft(const arr_real& x) {`
	`22`	`+arr_cmplx fft(span_t<real_t> x) {`
`23`	`23`	`auto plan = fft_plan_r(x.size());`
`24`	`24`	`return plan->solve(x);`
`25`	`25`	`}`
`26`	`26`
`27`		`-arr_cmplx fft(const arr_real& x, int n) {`
	`27`	`+arr_cmplx fft(span_t<real_t> x, int n) {`
`28`	`28`	`if (n == x.size()) {`
`29`	`29`	`return fft(x);`
`30`	`30`	`}`
`@@ -34,11 +34,11 @@ arr_cmplx fft(const arr_real& x, int n) {`
`34`	`34`	`return fft(x.slice(0, n));`
`35`	`35`	`}`
`36`	`36`
`37`		`-arr_cmplx rfft(const arr_real& x) {`
	`37`	`+arr_cmplx rfft(span_t<real_t> x) {`
`38`	`38`	`return fft(x);`
`39`	`39`	`}`
`40`	`40`
`41`		`-arr_cmplx rfft(const arr_real& x, int n) {`
	`41`	`+arr_cmplx rfft(span_t<real_t> x, int n) {`
`42`	`42`	`return fft(x, n);`
`43`	`43`	`}`
`44`	`44`