void magmaf_dorgqr_m( magma_int_t *m, magma_int_t *n, magma_int_t *k, double *A, magma_int_t *lda, double *tau, double *T, magma_int_t *nb, magma_int_t *info ) { magma_dorgqr_m( *m, *n, *k, A, *lda, tau, T, *nb, info ); }
/** Purpose ------- DORGHR generates a DOUBLE_PRECISION unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). Arguments --------- @param[in] n INTEGER The order of the matrix Q. N >= 0. @param[in] ilo INTEGER @param[in] ihi INTEGER ILO and IHI must have the same values as in the previous call of DGEHRD. Q is equal to the unit matrix except in the submatrix Q(ilo+1:ihi,ilo+1:ihi). 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0. @param[in,out] A DOUBLE_PRECISION array, dimension (LDA,N) On entry, the vectors which define the elementary reflectors, as returned by DGEHRD. On exit, the N-by-N unitary matrix Q. @param[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,N). @param[in] tau DOUBLE_PRECISION array, dimension (N-1) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEHRD. @param[in] T DOUBLE_PRECISION array on the GPU device. T contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 9th argument of magma_dgehrd. @param[in] nb INTEGER This is the block size used in DGEHRD, and correspondingly the size of the T matrices, used in the factorization, and stored in T. @param[out] info INTEGER - = 0: successful exit - < 0: if INFO = -i, the i-th argument had an illegal value @ingroup magma_dgeev_comp ********************************************************************/ extern "C" magma_int_t magma_dorghr_m( magma_int_t n, magma_int_t ilo, magma_int_t ihi, double *A, magma_int_t lda, double *tau, double *T, magma_int_t nb, magma_int_t *info) { #define A(i,j) (A + (i) + (j)*lda) magma_int_t i, j, nh, iinfo; *info = 0; nh = ihi - ilo; if (n < 0) *info = -1; else if (ilo < 1 || ilo > max(1,n)) *info = -2; else if (ihi < min(ilo,n) || ihi > n) *info = -3; else if (lda < max(1,n)) *info = -5; if (*info != 0) { magma_xerbla( __func__, -(*info) ); return *info; } /* Quick return if possible */ if (n == 0) return *info; /* Shift the vectors which define the elementary reflectors one column to the right, and set the first ilo and the last n-ihi rows and columns to those of the unit matrix */ for (j = ihi-1; j >= ilo; --j) { for (i = 0; i < j; ++i) *A(i, j) = MAGMA_D_ZERO; for (i = j+1; i < ihi; ++i) *A(i, j) = *A(i, j - 1); for (i = ihi; i < n; ++i) *A(i, j) = MAGMA_D_ZERO; } for (j = 0; j < ilo; ++j) { for (i = 0; i < n; ++i) *A(i, j) = MAGMA_D_ZERO; *A(j, j) = MAGMA_D_ONE; } for (j = ihi; j < n; ++j) { for (i = 0; i < n; ++i) *A(i, j) = MAGMA_D_ZERO; *A(j, j) = MAGMA_D_ONE; } if (nh > 0) { /* Generate Q(ilo+1:ihi,ilo+1:ihi) */ magma_dorgqr_m( nh, nh, nh, A(ilo, ilo), lda, tau+ilo-1, T, nb, &iinfo ); } return *info; } /* magma_dorghr */
extern "C" magma_int_t magma_dorghr_m( magma_int_t n, magma_int_t ilo, magma_int_t ihi, double *A, magma_int_t lda, double *tau, double *T, magma_int_t nb, magma_int_t *info) { /* -- MAGMA (version 1.4.1) -- Univ. of Tennessee, Knoxville Univ. of California, Berkeley Univ. of Colorado, Denver December 2013 Purpose ======= DORGHR generates a DOUBLE_PRECISION unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). Arguments ========= N (input) INTEGER The order of the matrix Q. N >= 0. ILO (input) INTEGER IHI (input) INTEGER ILO and IHI must have the same values as in the previous call of DGEHRD. Q is equal to the unit matrix except in the submatrix Q(ilo+1:ihi,ilo+1:ihi). 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0. A (input/output) DOUBLE_PRECISION array, dimension (LDA,N) On entry, the vectors which define the elementary reflectors, as returned by DGEHRD. On exit, the N-by-N unitary matrix Q. LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,N). TAU (input) DOUBLE_PRECISION array, dimension (N-1) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEHRD. T (input) DOUBLE_PRECISION array on the GPU device. T contains the T matrices used in blocking the elementary reflectors H(i), e.g., this can be the 9th argument of magma_dgehrd. NB (input) INTEGER This is the block size used in DGEHRD, and correspondingly the size of the T matrices, used in the factorization, and stored in T. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value ===================================================================== */ #define A(i,j) (A + (i) + (j)*lda) magma_int_t i, j, nh, iinfo; *info = 0; nh = ihi - ilo; if (n < 0) *info = -1; else if (ilo < 1 || ilo > max(1,n)) *info = -2; else if (ihi < min(ilo,n) || ihi > n) *info = -3; else if (lda < max(1,n)) *info = -5; if (*info != 0) { magma_xerbla( __func__, -(*info) ); return *info; } /* Quick return if possible */ if (n == 0) return *info; /* Shift the vectors which define the elementary reflectors one column to the right, and set the first ilo and the last n-ihi rows and columns to those of the unit matrix */ for (j = ihi-1; j >= ilo; --j) { for (i = 0; i < j; ++i) *A(i, j) = MAGMA_D_ZERO; for (i = j+1; i < ihi; ++i) *A(i, j) = *A(i, j - 1); for (i = ihi; i < n; ++i) *A(i, j) = MAGMA_D_ZERO; } for (j = 0; j < ilo; ++j) { for (i = 0; i < n; ++i) *A(i, j) = MAGMA_D_ZERO; *A(j, j) = MAGMA_D_ONE; } for (j = ihi; j < n; ++j) { for (i = 0; i < n; ++i) *A(i, j) = MAGMA_D_ZERO; *A(j, j) = MAGMA_D_ONE; } if (nh > 0) { /* Generate Q(ilo+1:ihi,ilo+1:ihi) */ magma_dorgqr_m( nh, nh, nh, A(ilo, ilo), lda, tau+ilo-1, T, nb, &iinfo ); } return *info; } /* magma_dorghr */