add arithm operators for span, code refactoring (#97)

Author: vitalsong

include/dsplib/array.h

@@ -307,148 +307,54 @@ class base_array
     }
 
     //--------------------------------------------------------------------
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator+=(const T2& rhs) noexcept {
-        static_assert(is_scalar_v<T2>, "Type must be scalar");
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        for (auto& x : _vec) {
-            x += rhs;
-        }
-        return *this;
-    }
-
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator-=(const T2& rhs) noexcept {
-        static_assert(is_scalar_v<T2>, "Type must be scalar");
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        for (auto& x : _vec) {
-            x -= rhs;
-        }
-        return *this;
-    }
-
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator*=(const T2& rhs) noexcept {
-        static_assert(is_scalar_v<T2>, "Type must be scalar");
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        for (auto& x : _vec) {
-            x *= rhs;
-        }
-        return *this;
-    }
-
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator/=(const T2& rhs) {
-        static_assert(is_scalar_v<T2>, "Type must be scalar");
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        for (auto& x : _vec) {
-            x /= rhs;
-        }
-        return *this;
-    }
-
-    //--------------------------------------------------------------------
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator+(const T2& rhs) const {
-        auto temp = array_cast<R>(*this);
-        //TODO: optimize, not optimal for arr_cmplx + real_t
-        temp += rhs;
-        return temp;
-    }
-
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator-(const T2& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp -= rhs;
-        return temp;
-    }
-
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator*(const T2& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp *= rhs;
-        return temp;
-    }
-
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator/(const T2& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp /= rhs;
-        return temp;
-    }
-
-    //--------------------------------------------------------------------
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator+=(const base_array<T2>& rhs) {
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        DSPLIB_ASSERT(this->size() == rhs.size(), "array lengths must be equal");
-        for (size_t i = 0; i < _vec.size(); ++i) {
-            _vec[i] += rhs[i];
-        }
+    template<class T2>
+    base_array<T>& operator+=(const T2& rhs) noexcept {
+        make_span(_vec) += rhs;
         return *this;
     }
 
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator-=(const base_array<T2>& rhs) {
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        DSPLIB_ASSERT(this->size() == rhs.size(), "array lengths must be equal");
-        for (size_t i = 0; i < _vec.size(); ++i) {
-            _vec[i] -= rhs[i];
-        }
+    template<class T2>
+    base_array<T>& operator-=(const T2& rhs) noexcept {
+        make_span(_vec) -= rhs;
         return *this;
     }
 
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator*=(const base_array<T2>& rhs) {
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        DSPLIB_ASSERT(this->size() == rhs.size(), "array lengths must be equal");
-        for (size_t i = 0; i < _vec.size(); ++i) {
-            _vec[i] *= rhs[i];
-        }
+    template<class T2>
+    base_array<T>& operator*=(const T2& rhs) noexcept {
+        make_span(_vec) *= rhs;
         return *this;
     }
 
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator/=(const base_array<T2>& rhs) {
-        static_assert(std::is_same_v<T, R>, "The operation changes the type");
-        DSPLIB_ASSERT(this->size() == rhs.size(), "array lengths must be equal");
-        for (size_t i = 0; i < _vec.size(); ++i) {
-            _vec[i] /= rhs[i];
-        }
+    template<class T2>
+    base_array<T>& operator/=(const T2& rhs) {
+        make_span(_vec) /= rhs;
         return *this;
     }
 
     //--------------------------------------------------------------------
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator+(const base_array<T2>& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp += rhs;
-        return temp;
+    //TODO: add lvalue + rvalue, rvalue + lvalue
+    template<class T2>
+    auto operator+(const T2& rhs) const {
+        return make_span(_vec) + rhs;
     }
 
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator-(const base_array<T2>& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp -= rhs;
-        return temp;
+    template<class T2>
+    auto operator-(const T2& rhs) const {
+        return make_span(_vec) - rhs;
     }
 
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator*(const base_array<T2>& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp *= rhs;
-        return temp;
+    template<class T2>
+    auto operator*(const T2& rhs) const {
+        return make_span(_vec) * rhs;
     }
 
-    template<class T2, class R = ResultType<T, T2>>
-    base_array<R> operator/(const base_array<T2>& rhs) const {
-        auto temp = array_cast<R>(*this);
-        temp /= rhs;
-        return temp;
+    template<class T2>
+    auto operator/(const T2& rhs) const {
+        return make_span(_vec) / rhs;
     }
 
-    //--------------------------------------------------------------------
-    //concatenate syntax
+    //concatenate syntax (deprecated)
+    //TODO: mark as deprecated?
     template<class T2, class R = ResultType<T, T2>>
     base_array<R>& operator|=(const base_array<T2>& rhs) {
         _vec.insert(_vec.end(), rhs.begin(), rhs.end());
@@ -507,34 +413,35 @@ class base_array
 
 //--------------------------------------------------------------------------------
 //left oriented scalar * array
-template<class T, class Scalar, class R = ResultType<T, Scalar>, class S_ = enable_scalar_t<Scalar>,
-         class C_ = enable_convertible_t<Scalar, R>>
-inline base_array<R> operator+(const Scalar& lhs, const base_array<T>& rhs) {
-    return rhs + R(lhs);
+template<class T, class Scalar, class = enable_scalar_t<Scalar>>
+auto operator+(const Scalar& lhs, const base_array<T>& rhs) {
+    using R = ResultType<T, Scalar>;
+    static_assert(std::is_convertible_v<Scalar, R>, "convertable type error");
+    return rhs + lhs;
 }
 
-template<class T, class Scalar, class R = ResultType<T, Scalar>, class S_ = enable_scalar_t<Scalar>,
-         class C_ = enable_convertible_t<Scalar, R>>
-inline base_array<R> operator-(const Scalar& lhs, const base_array<T>& rhs) {
-    auto r = array_cast<R>(rhs);
-    for (int i = 0; i < r.size(); ++i) {
-        r[i] = R(lhs) - rhs[i];
-    }
-    return r;
+template<class T, class S, class = enable_scalar_t<S>>
+auto operator-(const S& lhs, const base_array<T>& rhs) {
+    using R = ResultType<T, S>;
+    static_assert(std::is_convertible_v<S, R>, "convertable type error");
+    return (-rhs) + lhs;
 }
 
-template<class T, class Scalar, class R = ResultType<T, Scalar>, class S_ = enable_scalar_t<Scalar>,
-         class C_ = enable_convertible_t<Scalar, R>>
-inline base_array<R> operator*(const Scalar& lhs, const base_array<T>& rhs) {
-    return rhs * R(lhs);
+template<class T, class S, class = enable_scalar_t<S>>
+auto operator*(const S& lhs, const base_array<T>& rhs) {
+    using R = ResultType<T, S>;
+    static_assert(std::is_convertible_v<S, R>, "convertable type error");
+    return rhs * lhs;
 }
 
-template<class T, class Scalar, class R = ResultType<T, Scalar>, class S_ = enable_scalar_t<Scalar>,
-         class C_ = enable_convertible_t<Scalar, R>>
-inline base_array<R> operator/(const Scalar& lhs, const base_array<T>& rhs) {
-    auto r = array_cast<R>(rhs);
+template<class T, class S, class = enable_scalar_t<S>>
+auto operator/(const S& lhs, const base_array<T>& rhs) {
+    using R = ResultType<T, S>;
+    static_assert(std::is_convertible_v<S, R>, "convertable type error");
+    auto r = base_array<R>(rhs.size());
+    const auto d = R(lhs);
     for (int i = 0; i < r.size(); ++i) {
-        r[i] = R(lhs) / rhs[i];
+        r[i] = d / rhs[i];
     }
     return r;
 }

include/dsplib/slice.h

@@ -65,7 +65,7 @@ class slice_t
         return current;
     }
 
-    base_array<T> operator*() const noexcept {
+    [[deprecated("use `copy` instead")]] base_array<T> operator*() const noexcept {
         return base_array<T>(*this);
     }
 
@@ -74,6 +74,10 @@ class slice_t
         return slice_t(mut_slice_t<T>::make_slice(mdata, size, i1, i2, step));
     }
 
+    base_array<T> copy() const noexcept {
+        return base_array<T>(*this);
+    }
+
 protected:
     explicit slice_t(const T* data, int stride, int count)
       : data_{data}
@@ -165,8 +169,11 @@ class mut_slice_t
         return current;
     }
 
-    //TODO: replace to `copy` or `to_arr` function
-    base_array<T> operator*() const noexcept {
+    [[deprecated("use `copy` instead")]] base_array<T> operator*() const noexcept {
+        return base_array<T>(*this);
+    }
+
+    base_array<T> copy() const noexcept {
         return base_array<T>(*this);
     }