geqrf.hpp

Go to the documentation of this file.

 
//
// Copyright (c) 2021-2023, 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_GEQRF_HH
#define TLAPACK_GEQRF_HH
 
#include "tlapack/base/utils.hpp"
#include "tlapack/lapack/geqr2.hpp"
#include "tlapack/lapack/larfb.hpp"
#include "tlapack/lapack/larft.hpp"
 
namespace tlapack {
struct GeqrfOpts {
    size_t nb = 32;  
};
 
template <class T, TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
constexpr WorkInfo geqrf_worksize(const A_t& A,
                                  const tau_t& tau,
                                  const GeqrfOpts& opts = {})
{
    using idx_t = size_type<A_t>;
    using range = pair<idx_t, idx_t>;
    using work_t = matrix_type<A_t, tau_t>;
 
    // constants
    const idx_t m = nrows(A);
    const idx_t n = ncols(A);
    const idx_t k = min(m, n);
    const idx_t nb = min((idx_t)opts.nb, k);
 
    auto&& A11 = cols(A, range(0, nb));
    auto&& tauw1 = slice(tau, range(0, nb));
    WorkInfo workinfo = geqr2_worksize<T>(A11, tauw1);
 
    if (n > nb) {
        auto&& TT1 = slice(A, range(0, nb), range(0, nb));
        auto&& A12 = slice(A, range(0, m), range(nb, n));
        workinfo.minMax(larfb_worksize<T>(LEFT_SIDE, CONJ_TRANS, FORWARD,
                                          COLUMNWISE_STORAGE, A11, TT1, A12));
        if constexpr (is_same_v<T, type_t<work_t>>)
            workinfo += WorkInfo(nb, nb);
    }
 
    return workinfo;
}
 
template <TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t, TLAPACK_WORKSPACE work_t>
int geqrf_work(A_t& A, tau_t& tau, work_t& work, const GeqrfOpts& opts = {})
{
    using idx_t = size_type<A_t>;
    using range = pair<idx_t, idx_t>;
 
    // constants
    const idx_t m = nrows(A);
    const idx_t n = ncols(A);
    const idx_t k = min(m, n);
    const idx_t nb = min((idx_t)opts.nb, k);
 
    // check arguments
    tlapack_check((idx_t)size(tau) >= k);
 
    // Matrix TT
    auto [TT, work2] = (n > nb) ? reshape(work, nb, nb) : reshape(work, 0, 0);
 
    // Main computational loop
    for (idx_t j = 0; j < k; j += nb) {
        const idx_t ib = min(nb, k - j);
 
        // Compute the QR factorization of the current block A(j:m,j:j+ib)
        auto A11 = slice(A, range(j, m), range(j, j + ib));
        auto tauw1 = slice(tau, range(j, j + ib));
 
        geqr2_work(A11, tauw1, work);
 
        if (j + ib < n) {
            // Form the triangular factor of the block reflector H = H(j)
            // H(j+1) . . . H(j+ib-1)
            auto TT1 = slice(TT, range(0, ib), range(0, ib));
            larft(FORWARD, COLUMNWISE_STORAGE, A11, tauw1, TT1);
 
            // Apply H to A(j:m,j+ib:n) from the left
            auto A12 = slice(A, range(j, m), range(j + ib, n));
            larfb_work(LEFT_SIDE, CONJ_TRANS, FORWARD, COLUMNWISE_STORAGE, A11,
                       TT1, A12, work2);
        }
    }
 
    return 0;
}
 
template <TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
int geqrf(A_t& A, tau_t& tau, const GeqrfOpts& opts = {})
{
    using work_t = matrix_type<A_t, tau_t>;
    using T = type_t<work_t>;
    Create<work_t> new_matrix;
 
    // Allocate or get workspace
    WorkInfo workinfo = geqrf_worksize<T>(A, tau, opts);
    std::vector<T> work_;
    auto work = new_matrix(work_, workinfo.m, workinfo.n);
 
    return geqrf_work(A, tau, work, opts);
}
}  // namespace tlapack
#endif  // TLAPACK_GEQRF_HH