concepts.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_CONCEPTS_HH
#define TLAPACK_ARRAY_CONCEPTS_HH
 
#if __cplusplus >= 202002L
    #include <cmath>
    #include <concepts>
    #include <cstddef>
    #include <type_traits>
 
    #include "tlapack/base/arrayTraits.hpp"
    #include "tlapack/base/types.hpp"
 
namespace tlapack {
 
// C++ standard math functions:
using std::abs;
using std::ceil;
using std::floor;
using std::isinf;
using std::isnan;
using std::log2;
using std::max;
using std::min;
using std::pow;  // We only use pow(int, T), see below in the concept Real.
using std::sqrt;
 
// C++ standard types:
using std::pair;
 
namespace concepts {
    template <typename T>
    concept Arithmetic = requires(const T& a, const T& b, T& c)
    {
        // Arithmetic and assignment operations
        c = a + b;
        c = a - b;
        c = a * b;
        c = a / b;
        c = -a;
 
        // Arithmetic operations with assignment
        c += a;
        c -= a;
        c *= a;
        c /= a;
    };
    concept Arithmetic = requires(const T& a, const T& b, T& c) {…}
 
    template <typename T>
    concept Real = Arithmetic<T>&& std::totally_ordered<T>&&
        std::numeric_limits<T>::is_specialized&& requires(const T& a, T& b)
    {
        // Constructors
        T();
        T(0);
        T(0.0);
 
        // Assignment
        b = a;
 
        // Inf and NaN checks
        {
            isinf(a)
        }
        ->std::same_as<bool>;
        {
            isnan(a)
        }
        ->std::same_as<bool>;
 
        // Math functions
        abs(a);
        sqrt(a);
        pow(2, a);
        log2(a);
        ceil(a);
        floor(a);
        min(a, b);
        max(a, b);
    };
    concept Real = Arithmetic<T>&& std::totally_ordered<T>&& {…}
 
    template <typename T>
    concept Complex = Arithmetic<T>&& std::equality_comparable<T>&&
        Real<real_type<T>>&& requires(const T& a, T& b)
    {
        // Constructors
        T();
        T(real_type<T>(), real_type<T>());
 
        // Assignment
        b = a;
        b = real(a);
 
        // Accessors
        {
            real(a)
        }
        ->std::same_as<real_type<T>>;
        {
            imag(a)
        }
        ->std::same_as<real_type<T>>;
        {
            conj(a)
        }
        ->std::same_as<T>;
 
        // Math functions
        abs(a);
        sqrt(a);
    };
    concept Complex = Arithmetic<T>&& std::equality_comparable<T>&& {…}
 
    template <typename T>
    concept Scalar = Arithmetic<T>&& std::equality_comparable<T>&&
        Real<real_type<T>>&& Complex<complex_type<T>>&& requires(T&& a)
    {
        // Assignable from a rvalue reference
        a = std::forward<T>(a);
 
        // Math functions
        abs(a);
        sqrt(a);
    };
    concept Scalar = Arithmetic<T>&& std::equality_comparable<T>&& {…}
 
    template <typename vector_t>
    concept Vector = requires(const vector_t& v)
    {
        // Entry access using operator[i]
        v[0];
 
        // Number of entries
        {
            size(v)
        }
        ->std::integral<>;
    };
    concept Vector = requires(const vector_t& v) {…}
 
    template <typename vector_t>
    concept SliceableVector = Vector<vector_t>&& requires(const vector_t& v)
    {
        // Subvector view
        {
            slice(v, pair{0, 0})
        }
        ->Vector<>;
    };
    concept SliceableVector = Vector<vector_t>&& requires(const vector_t& v) {…}
 
    template <typename matrix_t>
    concept Matrix = requires(const matrix_t& A)
    {
        // Entry access using operator(i,j)
        A(0, 0);
 
        // Number of rows
        {
            nrows(A)
        }
        ->std::integral<>;
 
        // Number of columns
        {
            ncols(A)
        }
        ->std::integral<>;
 
        // Number of entries
        {
            size(A)
        }
        ->std::integral<>;
    };
    concept Matrix = requires(const matrix_t& A) {…}
 
    template <typename matrix_t>
    concept SliceableMatrix = Matrix<matrix_t>&& requires(const matrix_t& A)
    {
        // Submatrix view (matrix)
        {
            slice(A, pair{0, 1}, pair{0, 1})
        }
        ->Matrix<>;
 
        // View of multiple rows (matrix)
        {
            rows(A, pair{0, 1})
        }
        ->Matrix<>;
 
        // View of multiple columns (matrix)
        {
            cols(A, pair{0, 1})
        }
        ->Matrix<>;
 
        // Row view (vector)
        {
            row(A, 0)
        }
        ->Vector<>;
 
        // Column view (vector)
        {
            col(A, 0)
        }
        ->Vector<>;
 
        // View of a slice of a row (vector)
        {
            slice(A, 0, pair{0, 1})
        }
        ->Vector<>;
 
        // View of a slice of a column (vector)
        {
            slice(A, pair{0, 1}, 0)
        }
        ->Vector<>;
 
        // Diagonal view (vector)
        {
            diag(A)
        }
        ->Vector<>;
 
        // Off-diagonal view (vector)
        {
            diag(A, 1)
        }
        ->Vector<>;
    };
    concept SliceableMatrix = Matrix<matrix_t>&& requires(const matrix_t& A) {…}
 
    template <typename matrix_t>
    concept TransposableMatrix = Matrix<matrix_t>&& requires(const matrix_t& A)
    {
        // Transpose view
        {
            transpose_view(A)
        }
        ->Matrix<>;
    };
    concept TransposableMatrix = Matrix<matrix_t>&& requires(const matrix_t& A) {…}
 
    // Workspace matrices
 
    namespace internal {
        template <typename pair_t>
        concept PairOfTransposableMatrixAndOther =
            TransposableMatrix<typename pair_t::first_type>;
 
        template <typename pair_t>
        concept PairOfVectorAndOther = Vector<typename pair_t::first_type>;
    }  // namespace internal
 
    template <typename work_t>
    concept Workspace = requires(work_t& work)
    {
        // Reshape into a matrix
        {
            reshape(work, 0, 0)
        }
        ->internal::PairOfTransposableMatrixAndOther<>;
 
        // Reshape into a vector
        {
            reshape(work, 0)
        }
        ->internal::PairOfVectorAndOther<>;
    };
    concept Workspace = requires(work_t& work) {…}
 
    // Other scalar concepts
 
    template <typename T>
    concept Index = std::integral<T>;
 
    template <typename T>
    concept Side = std::convertible_to<T, tlapack::Side>;
 
    template <typename T>
    concept Direction = std::convertible_to<T, tlapack::Direction>;
 
    template <typename T>
    concept Op = std::convertible_to<T, tlapack::Op>;
 
    template <typename T>
    concept StoreV = std::convertible_to<T, tlapack::StoreV>;
 
    template <typename T>
    concept Norm = std::convertible_to<T, tlapack::Norm>;
 
    template <typename T>
    concept Uplo = std::convertible_to<T, tlapack::Uplo>;
 
    template <typename T>
    concept Diag = std::convertible_to<T, tlapack::Diag>;
 
    // Legacy vector and matrix types
 
    template <typename T>
    concept LegacyArray = requires(const T& A)
    {
        {
            (legacy_matrix(A)).layout
        }
        ->std::convertible_to<tlapack::Layout>;
        {
            (legacy_matrix(A)).m
        }
        ->std::convertible_to<size_type<T>>;
        {
            (legacy_matrix(A)).n
        }
        ->std::convertible_to<size_type<T>>;
        {
            (legacy_matrix(A)).ptr[0]
        }
        ->std::convertible_to<type_t<T>>;
        {
            (legacy_matrix(A)).ldim
        }
        ->std::convertible_to<size_type<T>>;
    };
    concept LegacyArray = requires(const T& A) {…}
 
    template <typename matrix_t>
    concept LegacyMatrix = Matrix<matrix_t>&& LegacyArray<matrix_t> &&
                           ((layout<matrix_t> == Layout::ColMajor) ||
                            (layout<matrix_t> == Layout::RowMajor));
 
    template <typename vector_t>
    concept LegacyVector = Vector<vector_t>&& LegacyArray<vector_t> &&
                           ((layout<vector_t> == Layout::ColMajor) ||
                            (layout<vector_t> == Layout::RowMajor) ||
                            (layout<vector_t> == Layout::Strided)) &&
                           requires(const vector_t& v)
    {
        {
            (legacy_vector(v)).n
        }
        ->std::convertible_to<size_type<vector_t>>;
        {
            (legacy_vector(v)).ptr[0]
        }
        ->std::convertible_to<type_t<vector_t>>;
        {
            (legacy_vector(v)).inc
        }
        ->std::convertible_to<size_type<vector_t>>;
    };
    concept LegacyVector = Vector<vector_t>&& LegacyArray<vector_t> && {…}
 
    // Matrix and vector types that can be created
 
    template <typename array_t>
    concept ConstructableArray = Matrix<matrix_type<array_t>>&&
        Vector<vector_type<array_t>>&& requires(std::vector<type_t<array_t>>& v,
                                                type_t<array_t>* ptr)
    {
        {
            Create<matrix_type<array_t>>()(v, 2, 3)
        }
        ->Matrix<>;
        {
            Create<vector_type<array_t>>()(v, 2)
        }
        ->Vector<>;
        {
            CreateStatic<matrix_type<array_t>, 5, 6>()(ptr)
        }
        ->Matrix<>;
        {
            CreateStatic<vector_type<array_t>, 5>()(ptr)
        }
        ->Vector<>;
    };
    concept ConstructableArray = Matrix<matrix_type<array_t>>&& {…}
 
    template <typename matrix_t>
    concept ConstructableMatrix =
        Matrix<matrix_t>&& ConstructableArray<matrix_t>&& requires(
            std::vector<type_t<matrix_t>>& v, type_t<matrix_t>* ptr)
    {
        {
            Create<matrix_t>()(v, 2, 3)
        }
        ->Matrix<>;
        {
            CreateStatic<matrix_t, 5, 6>()(ptr)
        }
        ->Matrix<>;
    };
    concept ConstructableMatrix = {…}
 
    template <typename matrix_t>
    concept ConstructableAndSliceableMatrix =
        SliceableMatrix<matrix_t>&& ConstructableMatrix<matrix_t>;
 
    template <typename vector_t>
    concept ConstructableVector =
        Vector<vector_t>&& ConstructableArray<vector_t>&& requires(
            std::vector<type_t<vector_t>>& v, type_t<vector_t>* ptr)
    {
        {
            Create<vector_t>()(v, 2)
        }
        ->Vector<>;
        {
            CreateStatic<vector_t, 5>()(ptr)
        }
        ->Vector<>;
    };
    concept ConstructableVector = {…}
 
    template <typename vector_t>
    concept ConstructableAndSliceableVector =
        SliceableVector<vector_t>&& ConstructableVector<vector_t>;
 
}  // namespace concepts
}  // namespace tlapack
 
    #define TLAPACK_MATRIX tlapack::concepts::Matrix
 
    #define TLAPACK_SMATRIX tlapack::concepts::SliceableMatrix
 
    #define TLAPACK_STMATRIX tlapack::concepts::SliceableTransposeMatrix
 
    #define TLAPACK_VECTOR tlapack::concepts::Vector
 
    #define TLAPACK_SVECTOR tlapack::concepts::SliceableVector
 
    #define TLAPACK_WORKSPACE tlapack::concepts::Workspace
 
    #define TLAPACK_SCALAR tlapack::concepts::Scalar
 
    #define TLAPACK_REAL tlapack::concepts::Real
 
    #define TLAPACK_COMPLEX tlapack::concepts::Complex
 
    #define TLAPACK_INDEX tlapack::concepts::Index
 
    #define TLAPACK_SIDE tlapack::concepts::Side
 
    #define TLAPACK_DIRECTION tlapack::concepts::Direction
 
    #define TLAPACK_OP tlapack::concepts::Op
 
    #define TLAPACK_STOREV tlapack::concepts::StoreV
 
    #define TLAPACK_NORM tlapack::concepts::Norm
 
    #define TLAPACK_UPLO tlapack::concepts::Uplo
 
    #define TLAPACK_DIAG tlapack::concepts::Diag
 
    #define TLAPACK_LEGACY_ARRAY tlapack::concepts::LegacyArray
 
    #define TLAPACK_LEGACY_MATRIX tlapack::concepts::LegacyMatrix
 
    #define TLAPACK_LEGACY_VECTOR tlapack::concepts::LegacyVector
 
    #define TLAPACK_CMATRIX tlapack::concepts::ConstructableMatrix
 
    #define TLAPACK_CSMATRIX tlapack::concepts::ConstructableAndSliceableMatrix
 
    #define TLAPACK_CVECTOR tlapack::concepts::ConstructableVector
 
    #define TLAPACK_CSVECTOR tlapack::concepts::ConstructableAndSliceableVector
#else
    // Concepts are a C++20 feature, so just define them as `class` for earlier
    // versions
    #define TLAPACK_MATRIX class
    #define TLAPACK_SMATRIX class
    #define TLAPACK_STMATRIX class
 
    #define TLAPACK_VECTOR class
    #define TLAPACK_SVECTOR class
 
    #define TLAPACK_WORKSPACE class
 
    #define TLAPACK_SCALAR class
    #define TLAPACK_REAL class
    #define TLAPACK_COMPLEX class
    #define TLAPACK_INDEX class
 
    #define TLAPACK_SIDE class
    #define TLAPACK_DIRECTION class
    #define TLAPACK_OP class
    #define TLAPACK_STOREV class
    #define TLAPACK_NORM class
    #define TLAPACK_UPLO class
    #define TLAPACK_DIAG class
 
    #define TLAPACK_LEGACY_ARRAY class
    #define TLAPACK_LEGACY_MATRIX class
    #define TLAPACK_LEGACY_VECTOR class
 
    #define TLAPACK_CMATRIX class
    #define TLAPACK_CSMATRIX class
    #define TLAPACK_CVECTOR class
    #define TLAPACK_CSVECTOR class
#endif
 
#endif  // TLAPACK_ARRAY_CONCEPTS_HH