- Rename slice_t to mut_slice_t;

- Rename `const_slice_t` to `slice_t`;
- Add const initialization for `base_slice_t`;

Author: vitalsong

benchs/fft.cpp

@@ -92,13 +92,12 @@ BENCHMARK(BM_FFTW3_DOUBLE)
 #endif
 
 static void BM_FFT_DSPLIB(benchmark::State& state) {
-    using namespace dsplib;
     const int n = state.range(0);
     auto x = complex(dsplib::randn(n));
     dsplib::arr_cmplx y = dsplib::fft(x);   ///< update cache
     for (auto _ : state) {
         x[0] += 1e-5;
-        y = fft(x);
+        y = dsplib::fft(x);
     }
 }
 

include/dsplib/array.h

@@ -72,9 +72,12 @@ constexpr bool is_array_convertible() noexcept {
     return true;
 }
 
-//base dsplib array type
-//TODO: add array_view as parent for array/slice
-//TODO: add slice(vector<bool>)
+/**
+ * @brief base dsplib array type
+ * @todo add array_view as parent for array/slice
+ * @todo add slice(vector<bool>)
+ * @tparam T real_t/cmplx_t/int
+ */
 template<typename T>
 class base_array
 {
@@ -85,13 +88,13 @@ class base_array
       : _vec(n, 0) {
     }
 
-    base_array(const const_slice_t<T>& rhs)
+    base_array(const slice_t<T>& rhs)
       : base_array(rhs.size()) {
         this->slice(0, indexing::end) = rhs;
     }
 
-    base_array(const slice_t<T>& rhs)
-      : base_array(const_slice_t<T>(rhs)) {
+    base_array(const mut_slice_t<T>& rhs)
+      : base_array(slice_t<T>(rhs)) {
     }
 
     base_array(const std::vector<T>& v)
@@ -131,13 +134,13 @@ class base_array
     }
 
     template<typename T2>
-    explicit base_array(span_t<T2> v) {
+    explicit base_array(const span_t<T2>& v) {
         static_assert(is_array_convertible<T2, T>(), "Only real2real/cmplx2cmplx array cast support");
         _vec.assign(v.begin(), v.end());
     }
 
     template<typename T2>
-    explicit base_array(mut_span_t<T2> v)
+    explicit base_array(const mut_span_t<T2>& v)
       : base_array(span_t<T2>(v)) {
     }
 
@@ -275,20 +278,20 @@ class base_array
     }
 
     //--------------------------------------------------------------------
-    slice_t<T> slice(int i1, int i2, int m) {
-        return slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
+    mut_slice_t<T> slice(int i1, int i2, int m) {
+        return mut_slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
     }
 
-    const_slice_t<T> slice(int i1, int i2, int m) const {
-        return const_slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
+    slice_t<T> slice(int i1, int i2, int m) const {
+        return slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
     }
 
     //TODO: add slice(end, first, -1) like x[::-1] numpy
-    slice_t<T> slice(int i1, indexing::end_t, int m) {
+    mut_slice_t<T> slice(int i1, indexing::end_t, int m) {
         return this->slice(i1, size(), m);
     }
 
-    const_slice_t<T> slice(int i1, indexing::end_t, int m) const {
+    slice_t<T> slice(int i1, indexing::end_t, int m) const {
         return this->slice(i1, size(), m);
     }
 

include/dsplib/slice.h

@@ -11,92 +11,83 @@ namespace dsplib {
 template<typename T>
 class base_array;
 
-//TODO: rename `slice_t` to `mut_slice_t`
 template<typename T>
-class slice_t;
+class mut_slice_t;
 
-//TODO: rename `const_slice_t` to `slice_t`
 template<typename T>
-class const_slice_t;
+class slice_t;
 
-//----------------------------------------------------------------------------------------
-//TODO: support empty slices
 class base_slice_t
 {
 public:
     base_slice_t() = default;
 
-    explicit base_slice_t(int n, int i1, int i2, int m) {
-        //is empty
-        if (n == 0) {
+    explicit base_slice_t(int n, int i1, int i2, int m)
+      : _m{m}
+      , _n{n}
+      , _i1{(i1 < 0) ? (_n + i1) : (i1)}
+      , _i2{(i2 < 0) ? (_n + i2) : (i2)}
+      , _nc{_count()} {
+        if (_n == 0) {
             return;
         }
 
         DSPLIB_ASSERT(m != 0, "Slice stride cannot be zero");
-
-        _m = m;
-        _n = n;
-        _i1 = (i1 < 0) ? (_n + i1) : (i1);
-        _i2 = (i2 < 0) ? (_n + i2) : (i2);
-        const int d = std::abs(_i2 - _i1);
-        const int tm = std::abs(_m);
-        _nc = (d % tm != 0) ? (d / tm + 1) : (d / tm);
-
-        if ((_i1 < 0) || (_i1 >= _n)) {
-            DSPLIB_THROW("Left slice index out of range");
-        }
-
-        if ((_i2 < 0) || (_i2 > _n)) {
-            DSPLIB_THROW("Right slice index out of range");
-        }
-
-        if ((_m < 0) && (_i1 < _i2)) {
-            DSPLIB_THROW("First index is smaller for negative step");
-        }
-
-        if ((_m > 0) && (_i1 > _i2)) {
-            DSPLIB_THROW("First index is greater for positive step");
-        }
-
-        if (_nc > _n) {
-            DSPLIB_THROW("Slice range is greater vector size");
-        }
+        DSPLIB_ASSERT((_i1 >= 0) && (_i1 < _n), "Left slice index out of range");
+        DSPLIB_ASSERT((_i2 >= 0) && (_i2 <= _n), "Right slice index out of range");
+        DSPLIB_ASSERT(!((_m < 0) && (_i1 < _i2)), "First index is smaller for negative step");
+        DSPLIB_ASSERT(!((_m > 0) && (_i1 > _i2)), "First index is greater for positive step");
+        DSPLIB_ASSERT(_nc <= _n, "Slice range is greater array size");
     }
 
     bool empty() const noexcept {
         return (_nc == 0);
     }
 
 protected:
-    int _i1{0};
-    int _i2{0};
-    int _m{0};
-    int _n{0};
-    int _nc{0};
+    const int _m{1};
+    const int _n{0};
+    const int _i1{0};
+    const int _i2{0};
+    const int _nc{0};
+
+private:
+    int _count() const noexcept {
+        if (_n == 0) {
+            return 0;
+        }
+        const int d = std::abs(_i2 - _i1);
+        const int tm = std::abs(_m);
+        const int size = (d % tm != 0) ? (d / tm + 1) : (d / tm);
+        return size;
+    }
 };
 
-//----------------------------------------------------------------------------------------
-//TODO: add concatenate array = slice | array
+/**
+ * @brief Non-mutable slice object
+ * @todo add concatenate array = slice | array
+ * @tparam T real_t/cmplx_t
+ */
 template<typename T>
-class const_slice_t : public base_slice_t
+class slice_t : public base_slice_t
 {
 public:
-    friend class slice_t<T>;
+    friend class mut_slice_t<T>;
     using const_iterator = SliceIterator<const T>;
 
-    const_slice_t() = default;
+    slice_t() = default;
 
-    const_slice_t(const T* data, int size, int i1, int i2, int m)
+    slice_t(const T* data, int size, int i1, int i2, int m)
       : base_slice_t(size, i1, i2, m)
       , _data{data} {
     }
 
-    const_slice_t(const const_slice_t& rhs)
+    slice_t(const slice_t& rhs)
       : base_slice_t(rhs.size(), rhs._i1, rhs._i2, rhs._m)
       , _data{rhs._data} {
     }
 
-    const_slice_t(const slice_t<T>& rhs)
+    slice_t(const mut_slice_t<T>& rhs)
       : base_slice_t(rhs._n, rhs._i1, rhs._i2, rhs._m)
       , _data{rhs._data} {
     }
@@ -127,23 +118,26 @@ class const_slice_t : public base_slice_t
     const T* _data{nullptr};
 };
 
-//----------------------------------------------------------------------------------------
+/**
+ * @brief Mutable slice object
+ * @tparam T real_t/cmplx_t
+ */
 template<typename T>
-class slice_t : public base_slice_t
+class mut_slice_t : public base_slice_t
 {
 public:
-    friend class const_slice_t<T>;
+    friend class slice_t<T>;
     using iterator = SliceIterator<T>;
     using const_iterator = SliceIterator<const T>;
 
-    slice_t() = default;
+    mut_slice_t() = default;
 
-    slice_t(T* data, int size, int i1, int i2, int m)
+    mut_slice_t(T* data, int size, int i1, int i2, int m)
       : base_slice_t(size, i1, i2, m)
       , _data{data} {
     }
 
-    slice_t(const slice_t& rhs)
+    mut_slice_t(const mut_slice_t& rhs)
       : base_slice_t(rhs._n, rhs._i1, rhs._i2, rhs._m)
       , _data{rhs._data} {
     }
@@ -156,7 +150,7 @@ class slice_t : public base_slice_t
         return _m;
     }
 
-    slice_t& operator=(const const_slice_t<T>& rhs) {
+    mut_slice_t& operator=(const slice_t<T>& rhs) {
         DSPLIB_ASSERT(this->size() == rhs.size(), "Slices size must be equal");
         const int count = this->size();
 
@@ -189,22 +183,23 @@ class slice_t : public base_slice_t
         return *this;
     }
 
-    slice_t& operator=(const slice_t<T>& rhs) {
-        *this = const_slice_t<T>(rhs);
+    mut_slice_t& operator=(const mut_slice_t<T>& rhs) {
+        *this = slice_t<T>(rhs);
         return *this;
     }
 
-    slice_t& operator=(const base_array<T>& rhs) {
+    mut_slice_t& operator=(const base_array<T>& rhs) {
         DSPLIB_ASSERT(!_is_same_array(rhs.slice(0, rhs.size())), "Assigned array to same slice");
-        return (*this = rhs.slice(0, rhs.size()));
+        *this = rhs.slice(0, rhs.size());
+        return *this;
     }
 
-    slice_t& operator=(const T& value) {
+    mut_slice_t& operator=(const T& value) {
         std::fill(begin(), end(), value);
         return *this;
     }
 
-    slice_t& operator=(const std::initializer_list<T>& rhs) {
+    mut_slice_t& operator=(const std::initializer_list<T>& rhs) {
         std::copy(rhs.begin(), rhs.end(), this->begin());
         return *this;
     }
@@ -234,7 +229,7 @@ class slice_t : public base_slice_t
     }
 
 protected:
-    bool _is_same_array(const const_slice_t<T>& rhs) const noexcept {
+    bool _is_same_array(const slice_t<T>& rhs) const noexcept {
         auto l1 = _data;
         auto r1 = _data + _nc;
         auto l2 = rhs._data;