arrayTraits.hpp

Go to the documentation of this file.

 
//
// Copyright (c) 2025, University of Colorado Denver. All rights reserved.
//
// This file is part of <T>LAPACK.
// <T>LAPACK is free software: you can redistribute it and/or modify it under
// the terms of the BSD 3-Clause license. See the accompanying LICENSE file.
 
#ifndef TLAPACK_ARRAY_TRAITS_HH
#define TLAPACK_ARRAY_TRAITS_HH
 
#include "tlapack/base/types.hpp"
 
namespace tlapack {
 
// C++ standard utils:
using std::enable_if_t;
using std::is_same_v;
 
namespace traits {
 
    template <class T, class = int>
    struct entry_type_trait {
        using type = void;
    };
 
    template <class T, class = int>
    struct size_type_trait {
        using type = std::size_t;
    };
 
    template <class array_t, class = int>
    struct layout_trait {
        static constexpr Layout value = Layout::Unspecified;
    };
 
    template <class matrix_t, class = int>
    struct CreateFunctor {
        static_assert(false && sizeof(matrix_t),
                      "Must use correct specialization");
 
        template <class T, class idx_t>
        constexpr auto operator()(std::vector<T>& v, idx_t m, idx_t n = 1) const
        {
            return matrix_t();
        }
 
        template <class T, class idx_t>
        constexpr auto operator()(std::vector<T>& v, idx_t n) const
        {
            return matrix_t();
        }
    };
 
    template <class matrix_t, int m, int n, class = int>
    struct CreateStaticFunctor {
        static_assert(false && sizeof(matrix_t),
                      "Must use correct specialization");
        static_assert(m >= 0 && n >= -1);
 
        template <typename T>
        constexpr auto operator()(T* v) const
        {
            return matrix_t();
        }
    };
 
    // Matrix and vector type deduction:
 
    template <class... matrix_t>
    struct matrix_type_traits;
 
    // Matrix type deduction for one type
    template <class matrix_t>
    struct matrix_type_traits<matrix_t, int> {
        using type = typename matrix_type_traits<matrix_t, matrix_t, int>::type;
    };
 
    // Matrix type deduction for three or more types
    template <class matrixA_t, class matrixB_t, class... matrix_t>
    struct matrix_type_traits<matrixA_t, matrixB_t, matrix_t...> {
        using type = typename matrix_type_traits<
            typename matrix_type_traits<matrixA_t, matrixB_t, int>::type,
            matrix_t...>::type;
    };
 
    template <class... vector_t>
    struct vector_type_traits;
 
    // Vector type deduction for one type
    template <class vector_t>
    struct vector_type_traits<vector_t, int> {
        using type = typename vector_type_traits<vector_t, vector_t, int>::type;
    };
 
    // Vector type deduction for three or more types
    template <class vectorA_t, class vectorB_t, class... vector_t>
    struct vector_type_traits<vectorA_t, vectorB_t, vector_t...> {
        using type = typename vector_type_traits<
            typename vector_type_traits<vectorA_t, vectorB_t, int>::type,
            vector_t...>::type;
    };
}  // namespace traits
 
// Aliases for the traits:
 
template <class T>
using type_t = typename traits::entry_type_trait<T, int>::type;
 
template <class T>
using size_type = typename traits::size_type_trait<T, int>::type;
 
template <class array_t>
constexpr Layout layout = traits::layout_trait<array_t, int>::value;
 
template <class T>
using Create = traits::CreateFunctor<T, int>;
 
template <class T, int m, int n = -1>
using CreateStatic = traits::CreateStaticFunctor<T, m, n, int>;
 
template <class... matrix_t>
using matrix_type = typename traits::matrix_type_traits<matrix_t..., int>::type;
 
template <class... vector_t>
using vector_type = typename traits::vector_type_traits<vector_t..., int>::type;
 
}  // namespace tlapack
 
#endif  // TLAPACK_ARRAY_TRAITS_HH