slice type refactoring

Author: vitalsong

include/dsplib/array.h

@@ -291,11 +291,11 @@ class base_array
 
     //--------------------------------------------------------------------
     mut_slice_t<T> slice(int i1, int i2, int m) {
-        return mut_slice_t<T>(_vec.data(), _vec.size(), i1, i2, m);
+        return mut_slice_t<T>::make_slice(_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);
+        return slice_t<T>::make_slice(_vec.data(), _vec.size(), i1, i2, m);
     }
 
     //TODO: add slice(end, first, -1) like x[::-1] numpy

include/dsplib/iterator.h

@@ -55,6 +55,14 @@ 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/slice.h

@@ -17,110 +17,76 @@ class mut_slice_t;
 template<typename T>
 class slice_t;
 
-class base_slice_t
-{
-public:
-    base_slice_t() = default;
-
-    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");
-        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 _m{1};
-    int _n{0};
-    int _i1{0};
-    int _i2{0};
-    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;
-    }
-};
-
-static_assert(std::is_trivially_copyable<base_slice_t>(), "type must be trivially copyable");
-
 /**
  * @brief Non-mutable slice object
  * @todo add concatenate array = slice | array
  * @tparam T real_t/cmplx_t
  */
 template<typename T>
-class slice_t : public base_slice_t
+class slice_t
 {
 public:
     friend class mut_slice_t<T>;
     using const_iterator = SliceIterator<const T>;
 
     slice_t() = default;
 
-    slice_t(const T* data, int size, int i1, int i2, int m)
-      : base_slice_t(size, i1, i2, m)
-      , _data{data} {
-    }
-
     slice_t(const mut_slice_t<T>& rhs)
-      : base_slice_t(rhs._n, rhs._i1, rhs._i2, rhs._m)
-      , _data{rhs._data} {
+      : data_{rhs.data_}
+      , stride_{rhs.stride_}
+      , count_{rhs.count_} {
     }
 
     [[nodiscard]] int size() const noexcept {
-        return _nc;
+        return count_;
+    }
+
+    bool empty() const noexcept {
+        return count_ == 0;
     }
 
     [[nodiscard]] int stride() const noexcept {
-        return _m;
+        return stride_;
     }
 
     const_iterator begin() const noexcept {
-        return const_iterator(_data + _i1, _m);
+        return const_iterator(data_, stride_);
     }
 
     const_iterator end() const noexcept {
         auto current = begin();
-        std::advance(current, _nc);
+        std::advance(current, count_);
         return current;
     }
 
     base_array<T> operator*() const noexcept {
         return base_array<T>(*this);
     }
 
+    static slice_t make_slice(const T* data, int size, int i1, int i2, int step) {
+        auto mdata = const_cast<T*>(data);
+        return slice_t(mut_slice_t<T>::make_slice(mdata, size, i1, i2, step));
+    }
+
 protected:
-    const T* _data{nullptr};
+    explicit slice_t(const T* data, int stride, int count)
+      : data_{data}
+      , stride_{stride}
+      , count_{count} {
+        DSPLIB_ASSERT(count >= 0, "Count of elements must be positive");
+    }
+
+    const T* data_{nullptr};
+    int stride_{0};
+    int count_{0};
 };
 
 /**
  * @brief Mutable slice object
  * @tparam T real_t/cmplx_t
  */
 template<typename T>
-class mut_slice_t : public base_slice_t
+class mut_slice_t
 {
 public:
     friend class slice_t<T>;
@@ -129,17 +95,16 @@ class mut_slice_t : public base_slice_t
 
     mut_slice_t() = default;
 
-    mut_slice_t(T* data, int size, int i1, int i2, int m)
-      : base_slice_t(size, i1, i2, m)
-      , _data{data} {
+    [[nodiscard]] int size() const noexcept {
+        return count_;
     }
 
-    [[nodiscard]] int size() const noexcept {
-        return _nc;
+    bool empty() const noexcept {
+        return count_ == 0;
     }
 
     [[nodiscard]] int stride() const noexcept {
-        return _m;
+        return stride_;
     }
 
     mut_slice_t& operator=(const slice_t<T>& rhs) {
@@ -152,14 +117,14 @@ class mut_slice_t : public base_slice_t
         }
 
         //simple block copy/move (optimization)
-        const bool is_same = _is_same_array(rhs);
+        const bool is_same = is_same_memory(rhs, slice_t(*this));
         if ((this->stride() == 1) && (rhs.stride() == 1)) {
             const auto* src = &(*rhs.begin());
             auto* dst = &(*begin());
             if (!is_same) {
                 std::memcpy(dst, src, count * sizeof(*src));
             } else {
-                //TODO: check overlap and use memcpy
+                //overlapped
                 std::memmove(dst, src, count * sizeof(*src));
             }
             return *this;
@@ -181,7 +146,7 @@ class mut_slice_t : public base_slice_t
     }
 
     mut_slice_t& operator=(const base_array<T>& rhs) {
-        DSPLIB_ASSERT(!_is_same_array(rhs.slice(0, rhs.size())), "Assigned array to same slice");
+        DSPLIB_ASSERT(!is_same_memory(rhs.slice(0, rhs.size()), *this), "Assigned array to same slice");
         *this = rhs.slice(0, rhs.size());
         return *this;
     }
@@ -197,39 +162,73 @@ class mut_slice_t : public base_slice_t
     }
 
     iterator begin() noexcept {
-        return iterator(_data + _i1, _m);
+        return iterator(data_, stride_);
     }
 
     iterator end() noexcept {
         auto current = begin();
-        std::advance(current, _nc);
+        std::advance(current, count_);
         return current;
     }
 
     const_iterator begin() const noexcept {
-        return const_iterator(_data + _i1, _m);
+        return const_iterator(data_, stride_);
     }
 
     const_iterator end() const noexcept {
         auto current = begin();
-        std::advance(current, _nc);
+        std::advance(current, count_);
         return current;
     }
 
     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;
+        }
+        auto start1 = r1.begin();
+        auto end1 = r1.end();
+        auto start2 = r2.begin();
+        auto end2 = r2.end();
+        return (start1 < end2) && (start2 < end1);
+    }
+
+    static mut_slice_t make_slice(T* data, int size, int i1, int i2, int step) {
+        if (size == 0) {
+            return mut_slice_t();
+        }
+
+        i1 = (i1 < 0) ? (size + i1) : i1;
+        i2 = (i2 < 0) ? (size + i2) : i2;
+
+        const int d = std::abs(i2 - i1);
+        const int tm = std::abs(step);
+        int count = (d % tm != 0) ? (d / tm + 1) : (d / tm);
+
+        DSPLIB_ASSERT(step != 0, "Slice stride cannot be zero");
+        DSPLIB_ASSERT((i1 >= 0) && (i1 < size), "Left slice index out of range");
+        DSPLIB_ASSERT((i2 >= 0) && (i2 <= size), "Right slice index out of range");
+        DSPLIB_ASSERT(!((step < 0) && (i1 < i2)), "First index is smaller for negative step");
+        DSPLIB_ASSERT(!((step > 0) && (i1 > i2)), "First index is greater for positive step");
+        DSPLIB_ASSERT(count <= size, "Slice range is greater array size");
+
+        return mut_slice_t(data + i1, step, count);
+    }
+
 protected:
-    bool _is_same_array(const slice_t<T>& rhs) const noexcept {
-        auto l1 = _data;
-        auto r1 = _data + _nc;
-        auto l2 = rhs._data;
-        auto r2 = rhs._data + rhs._nc;
-        return ((l2 >= l1) && (l2 <= r1)) || ((r2 >= l1) && (r2 <= r1));
+    explicit mut_slice_t(T* data, int stride, int count)
+      : data_{data}
+      , stride_{stride}
+      , count_{count} {
+        DSPLIB_ASSERT(count >= 0, "Count of elements must be positive");
     }
 
-    T* _data{nullptr};
+    T* data_{nullptr};
+    int stride_{0};
+    int count_{0};
 };
 
 }   // namespace dsplib