Array cast support for custom types (#100)

- Add `cast<T>` function for array;
- Mark `to_vec` and `cast` as noexcept;
- Remove `array_cast` function;
- Fix conanfile recipe;

Author: vitalsong

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.15)
-project(dsplib LANGUAGES CXX VERSION 0.55.3)
+project(dsplib LANGUAGES CXX VERSION 1.0.0)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

conanfile.py

@@ -1,7 +1,10 @@
 from conan import ConanFile
 from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout
+from conan.tools.build import check_min_cppstd
 import re
 
+required_conan_version = ">=2.1.0"
+
 
 def get_version():
     try:
@@ -16,30 +19,35 @@ def get_version():
 class DsplibConan(ConanFile):
     name = "dsplib"
     version = get_version()
-
     license = "MIT"
     author = "Vitaly Yulis ([email protected])"
     url = "https://github.com/vitalsong/dsplib"
     description = "C++ DSP library for MATLAB/Octave similar programming"
     topics = ("dsp", "matlab", "c++17", "audio")
 
     settings = "os", "compiler", "build_type", "arch"
+
     options = {
         "shared": [True, False],
         "fPIC": [True, False],
         "float32": [True, False],
         "noexcept": [True, False],
     }
+
     default_options = {
         "shared": False,
         "fPIC": True,
         "float32": False,
         "noexcept": False,
     }
-    generators = "CMakeDeps"
 
-    exports_sources = "cmake/*", "CMakeLists.txt", "lib/*", "include/*"
+    generators = ["CMakeDeps"]
 
+    exports_sources = "cmake/*", "CMakeLists.txt", "lib/*", "include/*"
+    
+    def validate(self):
+        check_min_cppstd(self, 17)
+        
     def config_options(self):
         if self.settings.os == "Windows":
             del self.options.fPIC
@@ -49,10 +57,11 @@ def layout(self):
 
     def generate(self):
         tc = CMakeToolchain(self)
-        if self.options.float32:
-            tc.variables["DSPLIB_USE_FLOAT32"] = "ON"
-        if self.options.noexcept:
-            tc.variables["DSPLIB_NO_EXCEPTIONS"] = "ON"
+        tc.variables["DSPLIB_USE_FLOAT32"] = self.options.float32
+        tc.variables["DSPLIB_NO_EXCEPTIONS"] = self.options.noexcept
+        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
+        if self.options.get_safe("fPIC"):
+            tc.variables["CMAKE_POSITION_INDEPENDENT_CODE"] = self.options.fPIC
         tc.generate()
 
     def build(self):

include/dsplib/array.h

@@ -359,34 +359,44 @@ class base_array
     }
 
     //concatenate syntax
-    //TODO: mark as deprecated
     template<class T2, class R = ResultType<T, T2>>
-    base_array<R>& operator|=(const base_array<T2>& rhs) {
+    base_array& operator|=(const base_array<T2>& rhs) {
+        static_assert(std::is_same_v<T, R>, "not supported array cast");
         _vec.insert(_vec.end(), rhs.begin(), rhs.end());
         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 |= array_cast<R>(rhs);
-        return temp;
+        auto r = this->cast<R>();
+        r |= rhs;
+        return r;
     }
 
     template<typename R>
-    std::vector<R> to_vec() const {
+    [[nodiscard]] std::vector<R> to_vec() const noexcept {
         if constexpr (std::is_same_v<T, R>) {
             return _vec;
         } else {
-            static_assert(std::is_convertible_v<T, R>, "type is not convertible");
+            static_assert(std::is_convertible_v<T, R>, "type must be convertible");
             return std::vector<R>(_vec.begin(), _vec.end());
         }
     }
 
-    const std::vector<T>& to_vec() const noexcept {
+    [[nodiscard]] const std::vector<T>& to_vec() const noexcept {
         return _vec;
     }
 
+    template<typename R>
+    [[nodiscard]] auto cast() const noexcept {
+        if constexpr (std::is_same_v<T, R>) {
+            return *this;
+        } else {
+            static_assert(std::is_convertible_v<T, R>, "type must be convertible");
+            return base_array<R>(this->to_vec<R>());
+        }
+    }
+
     //apply per element function
     template<class Fn>
     auto apply(Fn func) const {

include/dsplib/traits.h

@@ -38,23 +38,6 @@ constexpr auto reduce_operator_type() noexcept {
 template<typename T1, typename T2>
 using ResultType = decltype(reduce_operator_type<T1, T2>());
 
-template<typename T_dst, typename T_src>
-constexpr 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>

lib/math.cpp

@@ -471,7 +471,7 @@ arr_cmplx power(const arr_cmplx& x, real_t n) {
 template<typename T>
 static base_array<T> _power(const base_array<T>& x, int n) {
     if (n == 0) {
-        return array_cast<T>(ones(x.size()));
+        return ones(x.size()).template cast<T>();
     }
     if (n == 1) {
         return x;

tests/arr_real_test.cpp

@@ -36,6 +36,17 @@ TEST(ArrRealTest, Cast) {
         const arr_real x2(x1);
         ASSERT_EQ_ARR_REAL(x1, x2);
     }
+    {
+        const arr_int x1 = arange(0, 10).cast<int>();
+        const arr_real x2(x1);
+        ASSERT_EQ_ARR_REAL(x1, x2);
+    }
+    {
+        const arr_real x1 = arange(0, 10);
+        const arr_cmplx x2 = x1.cast<cmplx_t>();
+        ASSERT_EQ_ARR_REAL(real(x2), x1);
+        ASSERT_EQ_ARR_REAL(imag(x2), zeros(x1.size()));
+    }
     {
         arr_real x1 = {1, 2, 3, 4, 5};
         x1 = x1;