traits.hpp

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

namespace etl {

namespace traits_detail {

template <typename T>
struct is_fast_matrix_impl : std::false_type {};

template <typename V1, typename V2, order V3, size_t... R>
struct is_fast_matrix_impl<fast_matrix_impl<V1, V2, V3, R...>> : std::true_type {};

template <typename T>
struct is_custom_fast_matrix_impl : std::false_type {};

template <typename V1, typename V2, order V3, size_t... R>
struct is_custom_fast_matrix_impl<custom_fast_matrix_impl<V1, V2, V3, R...>> : std::true_type {};

template <typename T>
struct is_dyn_matrix_impl : std::false_type {};

template <typename V1, order V2, size_t V3>
struct is_dyn_matrix_impl<dyn_matrix_impl<V1, V2, V3>> : std::true_type {};

template <typename T>
struct is_gpu_dyn_matrix_impl : std::false_type {};

template <typename V1, order V2, size_t V3>
struct is_gpu_dyn_matrix_impl<gpu_dyn_matrix_impl<V1, V2, V3>> : std::true_type {};

template <typename T>
struct is_custom_dyn_matrix_impl : std::false_type {};

template <typename V1, order V2, size_t V3>
struct is_custom_dyn_matrix_impl<custom_dyn_matrix_impl<V1, V2, V3>> : std::true_type {};

template <typename T>
struct is_sparse_matrix_impl : std::false_type {};

template <typename V1, sparse_storage V2, size_t V3>
struct is_sparse_matrix_impl<sparse_matrix_impl<V1, V2, V3>> : std::true_type {};

template <typename T>
struct is_dyn_matrix_view : std::false_type {};

template <typename E, size_t D>
struct is_dyn_matrix_view<dyn_matrix_view<E, D>> : std::true_type {};

template <typename T>
struct is_sub_view : std::false_type {};

template <typename E, bool Aligned>
struct is_sub_view<sub_view<E, Aligned>> : std::true_type {};

template <typename T>
struct is_selected_expr_impl : std::false_type {};

template <typename Selector, Selector V, typename Expr>
struct is_selected_expr_impl<selected_expr<Selector, V, Expr>> : std::true_type {};

template <template <typename, bool> typename BTE, typename T, bool B>
std::true_type is_base_of_template_tb_impl(const BTE<T, B>*);

template <template <typename, bool> typename BTE>
std::false_type is_base_of_template_tb_impl(...);

template <typename T, template <typename, bool> typename C>
constexpr bool is_base_of_template_tb = decltype(is_base_of_template_tb_impl<C>(std::declval<T*>()))::value;

template <typename E>
constexpr bool is_nongpu_temporary_impl() {
    if constexpr (is_base_of_template_tb<std::decay_t<E>, etl::base_temporary_expr>) {
        return !std::decay_t<E>::gpu_computable;
    } else {
        return false;
    }
}

template <typename E>
constexpr bool is_gpu_temporary_impl() {
    if constexpr (is_base_of_template_tb<std::decay_t<E>, etl::base_temporary_expr>) {
        return std::decay_t<E>::gpu_computable;
    } else {
        return false;
    }
}

} // end of namespace traits_detail

template <typename T>
constexpr bool is_fast_matrix = traits_detail::is_fast_matrix_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_custom_fast_matrix = traits_detail::is_custom_fast_matrix_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_dyn_matrix = traits_detail::is_dyn_matrix_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_gpu_dyn_matrix = traits_detail::is_gpu_dyn_matrix_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_custom_dyn_matrix = traits_detail::is_custom_dyn_matrix_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_sparse_matrix = traits_detail::is_sparse_matrix_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_unary_expr = cpp::specialization_of<etl::unary_expr, T>;

template <typename T>
constexpr bool is_binary_expr = cpp::specialization_of<etl::binary_expr, T>;

template <typename T>
constexpr bool is_generator_expr = cpp::specialization_of<etl::generator_expr, T>;

template <typename T>
constexpr bool is_optimized_expr = cpp::specialization_of<etl::optimized_expr, T>;

template <typename T>
constexpr bool is_serial_expr = cpp::specialization_of<etl::serial_expr, T>;

template <typename T>
constexpr bool is_selected_expr = traits_detail::is_selected_expr_impl<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_parallel_expr = cpp::specialization_of<etl::parallel_expr, T>;

template <typename T>
constexpr bool is_timed_expr = cpp::specialization_of<etl::timed_expr, T>;

template <typename T>
constexpr bool is_wrapper_expr = is_optimized_expr<T> || is_selected_expr<T> || is_serial_expr<T> || is_parallel_expr<T> || is_timed_expr<T>;

template <typename T>
constexpr bool is_sub_view = traits_detail::is_sub_view<std::decay_t<T>>::value;

template <typename T>
constexpr bool is_slice_view = cpp::specialization_of<etl::slice_view, T>;

template <typename T>
constexpr bool is_dyn_matrix_view = traits_detail::is_dyn_matrix_view<T>::value;

template <typename T>
constexpr bool is_transformer = decay_traits<T>::is_transformer;

template <typename T>
constexpr bool is_view = decay_traits<T>::is_view;

template <typename T>
constexpr bool is_magic_view = decay_traits<T>::is_magic_view;

template <typename T>
constexpr bool is_etl_expr = decay_traits<T>::is_etl;

template <typename T>
constexpr bool is_transpose_expr = cpp::specialization_of<etl::transpose_expr, T>;

template <typename T>
constexpr bool is_temporary_expr = traits_detail::is_base_of_template_tb<std::decay_t<T>, etl::base_temporary_expr>;

template <typename T>
constexpr bool is_etl_value = decay_traits<T>::is_value;

template <typename T>
constexpr bool is_etl_value_class =
    is_fast_matrix<T> || is_custom_fast_matrix<T> || is_dyn_matrix<T> || is_custom_dyn_matrix<T> || is_sparse_matrix<T> || is_gpu_dyn_matrix<T>;

template <typename T>
constexpr bool is_lhs = is_etl_value<T> || is_unary_expr<T>;

template <typename T>
constexpr bool is_simple_lhs = is_etl_value_class<T> || is_unary_expr<T> || is_sub_view<T> || is_slice_view<T> || is_dyn_matrix_view<T>;

template <typename T>
constexpr bool is_scalar = cpp::specialization_of<etl::scalar, T>;

template <typename T>
constexpr bool is_single_precision_t = std::is_same_v<T, float>;

template <typename T>
constexpr bool is_single_precision = is_single_precision_t<value_t<T>>;

template <typename... E>
constexpr bool all_single_precision = (is_single_precision<E> && ...);

template <typename T>
constexpr bool is_double_precision_t = std::is_same_v<T, double>;

template <typename T>
constexpr bool is_bool_t = std::is_same_v<T, bool>;

template <typename T>
constexpr bool is_double_precision = is_double_precision_t<value_t<T>>;

template <typename... E>
constexpr bool all_double_precision = (is_double_precision<E> && ...);

template <typename T>
constexpr bool is_floating = is_single_precision<T> || is_double_precision<T>;

template <typename T>
constexpr bool is_floating_t = is_single_precision_t<T> || is_double_precision_t<T>;

template <typename... E>
constexpr bool all_floating = (is_floating<E> && ...);

template <typename... E>
constexpr bool all_floating_t = (is_floating_t<E> && ...);

template <typename T>
constexpr bool is_complex_t = cpp::specialization_of<std::complex, T> || cpp::specialization_of<etl::complex, T>;

template <typename T>
constexpr bool is_complex_single_t = std::is_same_v<T, std::complex<float>> || std::is_same_v<T, etl::complex<float>>;

template <typename T>
constexpr bool is_complex_double_t = std::is_same_v<T, std::complex<double>> || std::is_same_v<T, etl::complex<double>>;

template <typename T>
constexpr bool is_complex_single_precision = is_complex_single_t<value_t<T>>;

template <typename T>
constexpr bool is_complex_double_precision = is_complex_double_t<value_t<T>>;

template <typename... E>
constexpr bool all_complex_single_precision = (is_complex_single_precision<E> && ...);

template <typename... E>
constexpr bool all_complex_double_precision = (is_complex_double_precision<E> && ...);

template <typename T>
constexpr bool is_complex = is_complex_single_precision<T> || is_complex_double_precision<T>;

template <typename... E>
constexpr bool all_complex = (is_complex<E> && ...);

template <typename T>
constexpr bool is_deep_single_precision = is_complex_single_precision<T> || is_single_precision<T>;

template <typename T>
constexpr bool is_deep_double_precision = is_complex_double_precision<T> || is_double_precision<T>;

template <typename T>
constexpr bool is_gpu_t = is_floating_t<T> || is_complex_t<T> || is_bool_t<T>;

template <typename T>
constexpr bool is_dma = decay_traits<T>::is_direct;

template <typename... E>
constexpr bool all_dma = (is_dma<E> && ...);

template <typename E>
constexpr bool is_row_major = decay_traits<E>::storage_order == order::RowMajor;

template <typename... E>
constexpr bool all_row_major = (is_row_major<E> & ...);

template <typename E>
constexpr bool is_column_major = decay_traits<E>::storage_order == order::ColumnMajor;

template <typename... E>
constexpr bool all_column_major = (is_column_major<E> && ...);

template <typename E>
constexpr bool is_fast = decay_traits<E>::is_fast;

template <typename... E>
constexpr bool all_fast = (decay_traits<E>::is_fast && ...);

template <typename... E>
constexpr bool all_etl_expr = (is_etl_expr<E> && ...);

template <typename T>
constexpr bool is_1d = decay_traits<T>::dimensions() == 1;

template <typename... T>
constexpr bool all_1d = (is_1d<T> && ...);

template <typename T>
constexpr bool is_2d = decay_traits<T>::dimensions() == 2;

template <typename... T>
constexpr bool all_2d = (is_2d<T> && ...);

template <typename T>
constexpr bool is_3d = decay_traits<T>::dimensions() == 3;

template <typename... T>
constexpr bool all_3d = (is_3d<T> && ...);

template <typename T>
constexpr bool is_4d = decay_traits<T>::dimensions() == 4;

template <typename... T>
constexpr bool all_4d = (is_4d<T> && ...);

template <vector_mode_t V, typename... E>
constexpr bool all_vectorizable = (decay_traits<E>::template vectorizable<V> && ...);

template <vector_mode_t V, typename E>
static constexpr bool vectorizable_t = get_intrinsic_traits<V>::template type<value_t<E>>::vectorizable;

template <vector_mode_t V, typename... E>
constexpr bool all_vectorizable_t = (vectorizable_t<V, E> & ...);

template <typename E>
constexpr bool is_thread_safe = decay_traits<E>::is_thread_safe;

template <typename... E>
constexpr bool all_thread_safe = (decay_traits<E>::is_thread_safe && ...);

template <typename T>
constexpr bool is_padded_value = is_dyn_matrix<T> || is_fast_matrix<T>;

template <typename T>
constexpr bool is_aligned_value = is_dyn_matrix<T> || is_fast_matrix<T>;

template <typename... E>
constexpr bool all_padded = (decay_traits<E>::is_padded && ...);

template <typename T>
constexpr bool is_gpu_computable = decay_traits<T>::gpu_computable;

template <typename... E>
constexpr bool all_gpu_computable = (decay_traits<E>::gpu_computable && ...);

template <typename... E>
constexpr bool all_homogeneous = cpp::is_homogeneous_v<value_t<E>...>;

template <typename T>
constexpr bool fast_sub_view_able = is_dma<T>&& decay_traits<T>::storage_order == order::RowMajor;

template <typename T>
constexpr bool fast_sub_matrix_able = is_dma<T>;

template <typename T>
constexpr bool fast_slice_view_able = fast_sub_view_able<T>;

namespace traits_detail {

template <typename T>
constexpr bool inplace_sub_transpose_able_impl() {
    if constexpr (is_fast<T> && is_3d<T>) {
        return decay_traits<T>::template dim<1>() == decay_traits<T>::template dim<2>();
    } else if constexpr (!is_fast<T> && is_3d<T>) {
        return true;
    } else {
        return false;
    }
}

template <typename T>
constexpr bool inplace_transpose_able_impl() {
    if constexpr (is_fast<T> && is_2d<T>) {
        return decay_traits<T>::template dim<0>() == decay_traits<T>::template dim<1>();
    } else if constexpr (!is_fast<T> && is_2d<T>) {
        return true;
    } else {
        return false;
    }
}

template <typename Matrix>
constexpr bool is_square_matrix_impl() {
    if constexpr (is_fast<Matrix> && is_2d<Matrix>) {
        return etl_traits<Matrix>::template dim<0>() == etl_traits<Matrix>::template dim<1>();
    } else if constexpr (!is_fast<Matrix> && is_2d<Matrix>) {
        return true;
    } else {
        return false;
    }
}

} //end of namespace traits_detail

template <typename T>
constexpr bool inplace_transpose_able = traits_detail::inplace_transpose_able_impl<T>();

template <typename T>
constexpr bool inplace_sub_transpose_able = traits_detail::inplace_sub_transpose_able_impl<T>();

template <typename Matrix>
constexpr bool is_square_matrix = traits_detail::is_square_matrix_impl<Matrix>();

template <typename E>
constexpr bool is_nongpu_temporary = traits_detail::is_nongpu_temporary_impl<E>();

template <typename E>
constexpr bool is_gpu_temporary = traits_detail::is_gpu_temporary_impl<E>();

template <typename E>
constexpr bool should_gpu_compute_direct = is_etl_value<E> || is_nongpu_temporary<E> || (is_dma<E> && !is_gpu_temporary<E>);

template <typename T, typename S>
using return_helper = std::conditional_t<
    std::is_const_v<std::remove_reference_t<S>>,
    const value_t<T>&,
    std::conditional_t<std::is_lvalue_reference_v<S> && !std::is_const_v<T>, value_t<T>&, value_t<T>>>;

template <typename T, typename S>
using const_return_helper = std::conditional_t<std::is_lvalue_reference_v<S>, const value_t<T>&, value_t<T>>;

template <typename T>
requires(is_etl_value_class<T>)
struct etl_traits<T> {
    using value_type = typename T::value_type; 

    static constexpr bool is_etl         = true;                                          
    static constexpr bool is_transformer = false;                                         
    static constexpr bool is_view        = false;                                         
    static constexpr bool is_magic_view  = false;                                         
    static constexpr bool is_fast        = is_fast_matrix<T> || is_custom_fast_matrix<T>; 
    static constexpr bool is_value       = true;                                          
    static constexpr bool is_direct      = !is_sparse_matrix<T>;                          
    static constexpr bool is_thread_safe = true;                                          
    static constexpr bool is_linear      = true;                                          
    static constexpr bool is_generator   = false;                                         
    static constexpr bool is_temporary   = false;                                         
    static constexpr bool is_padded      = is_padded_value<T>;                            
    static constexpr bool is_aligned     = is_aligned_value<T>;                           
    static constexpr order storage_order = T::storage_order;                              
    static constexpr bool gpu_computable = is_gpu_t<value_type> && cuda_enabled;          

    template <vector_mode_t V>
    static constexpr bool vectorizable = get_intrinsic_traits<V>::template type<value_type>::vectorizable && !is_sparse_matrix<T> && !is_gpu_dyn_matrix<T>;

    static size_t size(const T& v) {
        return v.size();
    }

    static size_t dim(const T& v, size_t d) {
        return v.dim(d);
    }

    static constexpr size_t size() requires(is_fast) {
        return T::size();
    }

    template <size_t D>
    static constexpr size_t dim() requires(is_fast) {
        return T::template dim<D>();
    }

    static constexpr size_t dimensions() {
        return T::n_dimensions;
    }

    static constexpr int complexity() noexcept {
        return -1;
    }
};

} //end of namespace etl