feurst commit

Author: Alexandre Hoffmann

include/xtensor/containers/xfixed.hpp

@@ -325,8 +325,7 @@ namespace xt
         explicit xfixed_container(const inner_shape_type& shape, layout_type l = L);
         explicit xfixed_container(const inner_shape_type& shape, value_type v, layout_type l = L);
 
-        // remove this enable_if when removing the other value_type constructor
-        template <class IX = std::integral_constant<std::size_t, N>, class EN = std::enable_if_t<IX::value != 0, int>>
+        template <class IX = std::integral_constant<std::size_t, N>> requires (IX::value != 0)
         xfixed_container(nested_initializer_list_t<value_type, N> t);
 
         ~xfixed_container() = default;
@@ -639,7 +638,7 @@ namespace xt
      * Note: for clang < 3.8 this is an initializer_list and the size is not checked at compile-or runtime.
      */
     template <class ET, class S, layout_type L, bool SH, class Tag>
-    template <class IX, class EN>
+    template <class IX> requires (IX::value != 0)
     inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(nested_initializer_list_t<value_type, N> t)
     {
         XTENSOR_ASSERT_MSG(

include/xtensor/containers/xscalar.hpp

@@ -316,7 +316,10 @@ namespace xt
 
     template <class E>
     using is_xscalar = detail::is_xscalar_impl<E>;
-
+    
+    template<class E>
+    concept is_xscalar_concept = is_xscalar<std::decay_t<E>>::value;
+    
     namespace detail
     {
         template <class... E>

include/xtensor/containers/xstorage.hpp

@@ -25,14 +25,6 @@
 
 namespace xt
 {
-
-    namespace detail
-    {
-        template <class It>
-        using require_input_iter = typename std::enable_if<
-            std::is_convertible<typename std::iterator_traits<It>::iterator_category, std::input_iterator_tag>::value>::type;
-    }
-
     template <class C>
     struct is_contiguous_container : std::true_type
     {
@@ -64,7 +56,7 @@ namespace xt
         explicit uvector(size_type count, const allocator_type& alloc = allocator_type());
         uvector(size_type count, const_reference value, const allocator_type& alloc = allocator_type());
 
-        template <class InputIt, class = detail::require_input_iter<InputIt>>
+        template <input_iterator_concept InputIt>
         uvector(InputIt first, InputIt last, const allocator_type& alloc = allocator_type());
 
         uvector(std::initializer_list<T> init, const allocator_type& alloc = allocator_type());
@@ -277,7 +269,7 @@ namespace xt
     }
 
     template <class T, class A>
-    template <class InputIt, class>
+    template <input_iterator_concept InputIt>
     inline uvector<T, A>::uvector(InputIt first, InputIt last, const allocator_type& alloc)
         : m_allocator(alloc)
         , p_begin(nullptr)
@@ -675,18 +667,18 @@ namespace xt
 
         svector(const std::vector<T>& vec);
 
-        template <class IT, class = detail::require_input_iter<IT>>
+        template <input_iterator_concept IT>
         svector(IT begin, IT end, const allocator_type& alloc = allocator_type());
 
-        template <std::size_t N2, bool I2, class = std::enable_if_t<N != N2, void>>
+        template <std::size_t N2, bool I2> requires (N != N2)
         explicit svector(const svector<T, N2, A, I2>& rhs);
 
         svector& operator=(const svector& rhs);
         svector& operator=(svector&& rhs) noexcept(std::is_nothrow_move_assignable<value_type>::value);
         svector& operator=(const std::vector<T>& rhs);
         svector& operator=(std::initializer_list<T> il);
 
-        template <std::size_t N2, bool I2, class = std::enable_if_t<N != N2, void>>
+        template <std::size_t N2, bool I2> requires (N != N2)
         svector& operator=(const svector<T, N2, A, I2>& rhs);
 
         svector(const svector& other);
@@ -809,15 +801,15 @@ namespace xt
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    template <class IT, class>
+    template <input_iterator_concept IT>
     inline svector<T, N, A, Init>::svector(IT begin, IT end, const allocator_type& alloc)
         : m_allocator(alloc)
     {
         assign(begin, end);
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    template <std::size_t N2, bool I2, class>
+    template <std::size_t N2, bool I2> requires (N != N2)
     inline svector<T, N, A, Init>::svector(const svector<T, N2, A, I2>& rhs)
         : m_allocator(rhs.get_allocator())
     {
@@ -876,7 +868,7 @@ namespace xt
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    template <std::size_t N2, bool I2, class>
+    template <std::size_t N2, bool I2> requires (N != N2)
     inline svector<T, N, A, Init>& svector<T, N, A, Init>::operator=(const svector<T, N2, A, I2>& rhs)
     {
         m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(

include/xtensor/core/xexpression.hpp

@@ -178,6 +178,9 @@ namespace xt
 
     template <class E>
     using is_xexpression = is_crtp_base_of<xexpression, E>;
+    
+    template <class E>
+    concept xexpression_concept = is_xexpression<E>::value;
 
     template <class E, class R = void>
     using enable_xexpression = typename std::enable_if<is_xexpression<E>::value, R>::type;

include/xtensor/core/xshape.hpp

@@ -508,6 +508,8 @@ namespace xt
         };
     }
 
+		template<typename T> concept fixed_shape_container_concept = detail::is_fixed<typename std::decay_t<T>::shape_type>::value;
+
     template <class... S>
     struct promote_shape
     {

include/xtensor/generators/xbuilder.hpp

@@ -833,7 +833,7 @@ namespace xt
         return detail::make_xgenerator(detail::concatenate_impl<CT...>(std::move(t), axis), shape);
     }
 
-    template <std::size_t axis, class... CT, typename = std::enable_if_t<detail::all_fixed_shapes<CT...>::value>>
+    template <std::size_t axis, fixed_shape_container_concept... CT>
     inline auto concatenate(std::tuple<CT...>&& t)
     {
         using shape_type = detail::concat_fixed_shape_t<axis, typename std::decay_t<CT>::shape_type...>;

include/xtensor/generators/xgenerator.hpp

@@ -59,6 +59,8 @@ namespace xt
 
     template <class F, class R, class S>
     class xgenerator;
+    
+		template<typename T> concept xgenerator_concept = is_specialization_of<xgenerator, std::decay_t<T>>::value;
 
     template <class C, class R, class S>
     struct xiterable_inner_types<xgenerator<C, R, S>>
@@ -80,10 +82,8 @@ namespace xt
      * overlapping_memory_checker_traits *
      *************************************/
 
-    template <class E>
-    struct overlapping_memory_checker_traits<
-        E,
-        std::enable_if_t<!has_memory_address<E>::value && is_specialization_of<xgenerator, E>::value>>
+    template <xgenerator_concept E> requires without_memory_address_concept<E>
+    struct overlapping_memory_checker_traits<E>
     {
         static bool check_overlap(const E&, const memory_range&)
         {
@@ -165,7 +165,7 @@ namespace xt
         template <class O>
         const_stepper stepper_end(const O& shape, layout_type) const noexcept;
 
-        template <class E, class FE = F, class = std::enable_if_t<has_assign_to<E, FE>::value>>
+        template <class E, class FE = F> requires has_assign_to_v<E, FE>
         void assign_to(xexpression<E>& e) const noexcept;
 
         const functor_type& functor() const noexcept;
@@ -371,7 +371,7 @@ namespace xt
     }
 
     template <class F, class R, class S>
-    template <class E, class, class>
+    template <class E, class FE> requires has_assign_to_v<E, FE>
     inline void xgenerator<F, R, S>::assign_to(xexpression<E>& e) const noexcept
     {
         e.derived_cast().resize(m_shape);

include/xtensor/generators/xrandom.hpp

@@ -29,6 +29,7 @@
 #include "../generators/xgenerator.hpp"
 #include "../views/xindex_view.hpp"
 #include "../views/xview.hpp"
+#include "../misc/xtl_concepts.hpp"
 
 namespace xt
 {
@@ -175,13 +176,11 @@ namespace xt
         template <class T, class E = random::default_engine_type>
         void shuffle(xexpression<T>& e, E& engine = random::get_default_random_engine());
 
-        template <class T, class E = random::default_engine_type>
-        std::enable_if_t<xtl::is_integral<T>::value, xtensor<T, 1>>
-        permutation(T e, E& engine = random::get_default_random_engine());
+        template <xtl::integral_concept T, class E = random::default_engine_type>
+				xtensor<T, 1> permutation(T e, E& engine = random::get_default_random_engine());
 
-        template <class T, class E = random::default_engine_type>
-        std::enable_if_t<is_xexpression<std::decay_t<T>>::value, std::decay_t<T>>
-        permutation(T&& e, E& engine = random::get_default_random_engine());
+        template <xexpression_concept T, class E = random::default_engine_type>
+				std::decay_t<T> permutation(T&& e, E& engine = random::get_default_random_engine());
 
         template <class T, class E = random::default_engine_type>
         xtensor<typename T::value_type, 1> choice(
@@ -835,17 +834,17 @@ namespace xt
          *
          * @return randomly permuted copy of container or arange.
          */
-        template <class T, class E>
-        std::enable_if_t<xtl::is_integral<T>::value, xtensor<T, 1>> permutation(T e, E& engine)
+        template <xtl::integral_concept T, class E>
+				xtensor<T, 1> permutation(T e, E& engine)
         {
             xt::xtensor<T, 1> res = xt::arange<T>(e);
             shuffle(res, engine);
             return res;
         }
 
         /// @cond DOXYGEN_INCLUDE_SFINAE
-        template <class T, class E>
-        std::enable_if_t<is_xexpression<std::decay_t<T>>::value, std::decay_t<T>> permutation(T&& e, E& engine)
+        template <xexpression_concept T, class E>
+				std::decay_t<T> permutation(T&& e, E& engine)
         {
             using copy_type = std::decay_t<T>;
             copy_type res = e;

include/xtensor/misc/xfft.hpp

@@ -5,6 +5,7 @@
 
 #include <xtl/xcomplex.hpp>
 
+#include "./xtl_concepts.hpp"
 #include "../containers/xarray.hpp"
 #include "../core/xmath.hpp"
 #include "../core/xnoalias.hpp"
@@ -19,9 +20,7 @@ namespace xt
     {
         namespace detail
         {
-            template <
-                class E,
-                typename std::enable_if<xtl::is_complex<typename std::decay<E>::type::value_type>::value, bool>::type = true>
+            template <xtl::complex_concept E>
             inline auto radix2(E&& e)
             {
                 using namespace xt::placeholders;
@@ -119,19 +118,19 @@ namespace xt
             }
         }  // namespace detail
 
-        /**
+			 /**
          * @brief 1D FFT of an Nd array along a specified axis
          * @param e an Nd expression to be transformed to the fourier domain
          * @param axis the axis along which to perform the 1D FFT
          * @return a transformed xarray of the specified precision
          */
-        template <
-            class E,
-            typename std::enable_if<xtl::is_complex<typename std::decay<E>::type::value_type>::value, bool>::type = true>
+        template<class E>
         inline auto fft(E&& e, std::ptrdiff_t axis = -1)
         {
-            using value_type = typename std::decay_t<E>::value_type;
-            using precision = typename value_type::value_type;
+					using value_type = typename std::decay<E>::type::value_type;
+					if constexpr (xtl::is_complex<typename std::decay<E>::type::value_type>::value)
+					{
+						using precision = typename value_type::value_type;
             const auto saxis = xt::normalize_axis(e.dimension(), axis);
             const size_t N = e.shape(saxis);
             const bool powerOfTwo = !(N == 0) && !(N & (N - 1));
@@ -150,29 +149,19 @@ namespace xt
                 }
             }
             return out;
-        }
-
-        /**
-         * @brief 1D FFT of an Nd array along a specified axis
-         * @param e an Nd expression to be transformed to the fourier domain
-         * @param axis the axis along which to perform the 1D FFT
-         * @return a transformed xarray of the specified precision
-         */
-        template <
-            class E,
-            typename std::enable_if<!xtl::is_complex<typename std::decay<E>::type::value_type>::value, bool>::type = true>
-        inline auto fft(E&& e, std::ptrdiff_t axis = -1)
-        {
-            using value_type = typename std::decay<E>::type::value_type;
-            return fft(xt::cast<std::complex<value_type>>(e), axis);
-        }
-
-        template <
-            class E,
-            typename std::enable_if<xtl::is_complex<typename std::decay<E>::type::value_type>::value, bool>::type = true>
-        auto ifft(E&& e, std::ptrdiff_t axis = -1)
+					}
+					else
+					{
+						return fft(xt::cast<std::complex<value_type>>(e), axis);
+					}
+				}
+
+        template <class E>
+        inline auto ifft(E&& e, std::ptrdiff_t axis = -1)
         {
-            // check the length of the data on that axis
+					if constexpr (xtl::is_complex<typename std::decay<E>::type::value_type>::value)
+					{
+						// check the length of the data on that axis
             const std::size_t n = e.shape(axis);
             if (n == 0)
             {
@@ -182,15 +171,12 @@ namespace xt
             auto fft_res = xt::fft::fft(complex_args, axis);
             fft_res = xt::conj(fft_res);
             return fft_res;
-        }
-
-        template <
-            class E,
-            typename std::enable_if<!xtl::is_complex<typename std::decay<E>::type::value_type>::value, bool>::type = true>
-        inline auto ifft(E&& e, std::ptrdiff_t axis = -1)
-        {
+					}
+					else
+					{
             using value_type = typename std::decay<E>::type::value_type;
             return ifft(xt::cast<std::complex<value_type>>(e), axis);
+					}
         }
 
         /*

include/xtensor/misc/xmanipulation.hpp

@@ -22,6 +22,7 @@
 #include "../utils/xutils.hpp"
 #include "../views/xrepeat.hpp"
 #include "../views/xstrided_view.hpp"
+#include "xtl_concepts.hpp"
 
 namespace xt
 {
@@ -64,7 +65,7 @@ namespace xt
     template <class E>
     auto squeeze(E&& e);
 
-    template <class E, class S, class Tag = check_policy::none, std::enable_if_t<!xtl::is_integral<S>::value, int> = 0>
+    template <class E, xtl::non_integral_concept S, class Tag = check_policy::none>
     auto squeeze(E&& e, S&& axis, Tag check_policy = Tag());
 
     template <class E>
@@ -210,20 +211,21 @@ namespace xt
             return transpose_impl(std::forward<E>(e), std::forward<S>(permutation), check_policy::none());
         }
 
-        template <class E, class S, class X, std::enable_if_t<has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline void compute_transposed_strides(E&& e, const S&, X& strides)
-        {
-            std::copy(e.strides().crbegin(), e.strides().crend(), strides.begin());
-        }
-
-        template <class E, class S, class X, std::enable_if_t<!has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline void compute_transposed_strides(E&&, const S& shape, X& strides)
+        template <class E, class S, class X>
+        inline void compute_transposed_strides(E&& e, const S& shape, X& strides)
         {
+					if constexpr (has_data_interface<std::decay_t<E>>::value)
+					{
+						std::copy(e.strides().crbegin(), e.strides().crend(), strides.begin());
+					}
+					else
+					{
             // In the case where E does not have a data interface, the transposition
             // makes use of a flat storage adaptor that has layout XTENSOR_DEFAULT_TRAVERSAL
             // which should be the one inverted.
             layout_type l = transpose_layout(XTENSOR_DEFAULT_TRAVERSAL);
             compute_strides(shape, l, strides);
+					}
         }
     }
 
@@ -588,7 +590,7 @@ namespace xt
      * @param check_policy select check_policy. With check_policy::full(), selecting an axis
      *        which is greater than one will throw a runtime_error.
      */
-    template <class E, class S, class Tag, std::enable_if_t<!xtl::is_integral<S>::value, int>>
+    template <class E, xtl::non_integral_concept S, class Tag>
     inline auto squeeze(E&& e, S&& axis, Tag check_policy)
     {
         return detail::squeeze_impl(std::forward<E>(e), std::forward<S>(axis), check_policy);