TestUploMatrix.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_TEST_TESTUPLOMATRIX_HH
#define TLAPACK_TEST_TESTUPLOMATRIX_HH
 
#include <tlapack/plugins/legacyArray.hpp>
 
namespace tlapack {
 
template <class T,
          class idx_t = std::size_t,
          Uplo uplo = Uplo::Upper,
          Layout L = Layout::ColMajor>
struct TestUploMatrix : public LegacyMatrix<T, idx_t, L> {
    int modifier =
        0;  
 
    TestUploMatrix(const LegacyMatrix<T, idx_t, L>& A)
        : LegacyMatrix<T, idx_t, L>(A)
    {}
 
    // Overload of the access operator
    constexpr const T& operator()(idx_t i, idx_t j) const noexcept
    {
        if (uplo == Uplo::Upper)
            assert((int)i <= (int)j + modifier);
        else if (uplo == Uplo::Lower)
            assert((int)i >= (int)j + modifier);
 
        return LegacyMatrix<T, idx_t, L>::operator()(i, j);
    };
 
    // Overload of the access operator
    constexpr T& operator()(idx_t i, idx_t j) noexcept
    {
        if (uplo == Uplo::Upper)
            assert((int)i <= (int)j + modifier);
        else if (uplo == Uplo::Lower)
            assert((int)i >= (int)j + modifier);
 
        return LegacyMatrix<T, idx_t, L>::operator()(i, j);
    };
};
struct TestUploMatrix : public LegacyMatrix<T, idx_t, L> {…};
 
// -----------------------------------------------------------------------------
// Data traits
 
namespace traits {
    template <typename T, class idx_t, Uplo uplo, Layout L>
    struct layout_trait<TestUploMatrix<T, idx_t, uplo, L>, int>
        : layout_trait<LegacyMatrix<T, idx_t, L>, int> {};
    struct layout_trait<TestUploMatrix<T, idx_t, uplo, L>, int> {…};
 
    template <typename T, class idx_t, Uplo uplo, Layout L>
    struct real_type_traits<TestUploMatrix<T, idx_t, uplo, L>, int>
        : real_type_traits<LegacyMatrix<T, idx_t, L>, int> {};
    struct real_type_traits<TestUploMatrix<T, idx_t, uplo, L>, int> {…};
 
    template <typename T, class idx_t, Uplo uplo, Layout L>
    struct complex_type_traits<TestUploMatrix<T, idx_t, uplo, L>, int>
        : complex_type_traits<LegacyMatrix<T, idx_t, L>, int> {};
    struct complex_type_traits<TestUploMatrix<T, idx_t, uplo, L>, int> {…};
 
    template <class T, class idx_t, Uplo uplo, Layout L>
    struct CreateFunctor<TestUploMatrix<T, idx_t, uplo, L>, int>
        : CreateFunctor<LegacyMatrix<T, idx_t, L>, int> {};
    struct CreateFunctor<TestUploMatrix<T, idx_t, uplo, L>, int> {…};
}  // namespace traits
 
// Block access specialization for TestUploMatrix
 
#define isSlice(SliceSpec) !std::is_convertible<SliceSpec, idx_t>::value
 
template <
    typename T,
    class idx_t,
    Uplo uplo,
    Layout layout,
    class SliceSpecRow,
    class SliceSpecCol,
    typename std::enable_if<isSlice(SliceSpecRow) && isSlice(SliceSpecCol),
                            int>::type = 0>
constexpr auto slice(const TestUploMatrix<T, idx_t, uplo, layout>& A,
                     SliceSpecRow&& rows,
                     SliceSpecCol&& cols) noexcept
{
    TestUploMatrix<const T, idx_t, uplo, layout> B(
        slice((const LegacyMatrix<T, idx_t, layout>&)A, rows, cols));
    B.modifier = A.modifier + cols.first - rows.first;
    return B;
}
 
#undef isSlice
 
template <typename T, class idx_t, Uplo uplo, Layout layout, class SliceSpec>
constexpr auto rows(const TestUploMatrix<T, idx_t, uplo, layout>& A,
                    SliceSpec&& slice) noexcept
{
    TestUploMatrix<const T, idx_t, uplo, layout> B(
        rows((const LegacyMatrix<T, idx_t, layout>&)A, slice));
    B.modifier = A.modifier - slice.first;
    return B;
}
 
template <typename T, class idx_t, Uplo uplo, Layout layout, class SliceSpec>
constexpr auto cols(const TestUploMatrix<T, idx_t, uplo, layout>& A,
                    SliceSpec&& slice) noexcept
{
    TestUploMatrix<const T, idx_t, uplo, layout> B(
        cols((const LegacyMatrix<T, idx_t, layout>&)A, slice));
    B.modifier = A.modifier + slice.first;
    return B;
}
 
#define isSlice(SliceSpec) !std::is_convertible<SliceSpec, idx_t>::value
 
template <
    typename T,
    class idx_t,
    Uplo uplo,
    Layout layout,
    class SliceSpecRow,
    class SliceSpecCol,
    typename std::enable_if<isSlice(SliceSpecRow) && isSlice(SliceSpecCol),
                            int>::type = 0>
constexpr auto slice(TestUploMatrix<T, idx_t, uplo, layout>& A,
                     SliceSpecRow&& rows,
                     SliceSpecCol&& cols) noexcept
{
    TestUploMatrix<T, idx_t, uplo, layout> B(
        slice((LegacyMatrix<T, idx_t, layout>&)A, rows, cols));
    B.modifier = A.modifier + cols.first - rows.first;
    return B;
}
 
#undef isSlice
 
template <typename T, class idx_t, Uplo uplo, Layout layout, class SliceSpec>
constexpr auto rows(TestUploMatrix<T, idx_t, uplo, layout>& A,
                    SliceSpec&& slice) noexcept
{
    TestUploMatrix<T, idx_t, uplo, layout> B(
        rows((LegacyMatrix<T, idx_t, layout>&)A, slice));
    B.modifier = A.modifier - slice.first;
    return B;
}
 
template <typename T, class idx_t, Uplo uplo, Layout layout, class SliceSpec>
constexpr auto cols(TestUploMatrix<T, idx_t, uplo, layout>& A,
                    SliceSpec&& slice) noexcept
{
    TestUploMatrix<T, idx_t, uplo, layout> B(
        cols((LegacyMatrix<T, idx_t, layout>&)A, slice));
    B.modifier = A.modifier + slice.first;
    return B;
}
 
}  // namespace tlapack
 
#endif  // TLAPACK_TEST_TESTUPLOMATRIX_HH