Commit 5c6df2e2 authored by BOUCHERIE Raphael's avatar BOUCHERIE Raphael
Browse files

added and modified files for testing of pzunmlq_param

parent f7161267
......@@ -130,6 +130,7 @@ set(ZSRC
pzungqr_param.c
pzungqrrh.c
pzunmlq.c
pzunmlq_param.c
pzunmlqrh.c
pzunmqr.c
pzunmqr_param.c
......@@ -177,6 +178,7 @@ set(ZSRC
zungqr.c
zungqr_param.c
zunmlq.c
zunmlq_param.c
zunmqr.c
zunmqr_param.c
ztpgqrt.c
......
......@@ -57,8 +57,8 @@ void morse_pzunmlq_param(const libhqr_tree_t *qrtree,
MORSE_desc_t *D = NULL;
int k, m, n, i, p;
int ldam, ldan, ldbm, ldak;
int tempnn, tempkmin, tempmm, tempkn;
int ldam, ldan, ldbm, ldak, ldbp;
int tempnn, tempkmin, tempmm, tempkn, tempkm;
int ib, K;
int *tiles;
......@@ -300,7 +300,7 @@ void morse_pzunmlq_param(const libhqr_tree_t *qrtree,
MORSE_TASK_ztsmlq(
&options,
side, trans,
tempmm, B->nb, tempmm, tempnn, tempkn, ib, TS->nb,
tempmm, B->nb, tempmm, tempnn, tempkm, ib, TS->nb,
B( p, n), ldbp,
B( m, n), ldbm,
A( k, n), ldak,
......@@ -313,8 +313,8 @@ void morse_pzunmlq_param(const libhqr_tree_t *qrtree,
MORSE_TASK_zttmlq(
&options,
side, trans,
tempmm, B->nb, tempmm, tempnn, tempkn, ib, TT->nb,
B( m, p), ldbp,
tempmm, B->nb, tempmm, tempnn, tempkm, ib, TT->nb,
B( p, n), ldbp,
B( m, n), ldbm,
A( k, n), ldak,
TT(k, n), TT->mb);
......@@ -322,35 +322,35 @@ void morse_pzunmlq_param(const libhqr_tree_t *qrtree,
}
}
for (i = 0; i < qrtree->getnbgeqrf(qrtree, k); i++) {
n = qrtree->getm(qrtree, k, i);
m = qrtree->getm(qrtree, k, i);
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
tempkmin = chameleon_min(tempnn, tempkn);
ldan = BLKLDD(A, n);
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
tempkmin = chameleon_min(tempmm, tempkm);
ldbm = BLKLDD(B, m);
#if defined(CHAMELEON_COPY_DIAG)
MORSE_TASK_zlacpy(
&options,
MorseUpper, tempnn, tempkmin, A->nb,
A(n, k), ldan,
D(n, k), ldan );
MorseUpper, tempkmin, tempkmm, A->nb,
A(k, m), ldak,
D(k, m), ldak );
#if defined(CHAMELEON_USE_CUDA)
MORSE_TASK_zlaset(
&options,
MorseLower, tempnn, tempkmin,
MorseLower, tempkmin, tempkmm,
0., 1.,
D(n, k), ldan );
D(k, m), ldak );
#endif
#endif
for (m = 0; m < B->mt; m++) {
for (n = 0; n < B->nt; n++) {
ldbm = BLKLDD(B, m);
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
MORSE_TASK_zunmlq(
&options,
side, trans,
tempmm, tempnn, tempkmin, ib, TS->nb,
D( n, k), ldan,
TS(n, k), TS->mb,
D( k, n), ldak,
TS(k, n), TS->mb,
B( m, n), ldbm);
}
}
......@@ -364,77 +364,74 @@ void morse_pzunmlq_param(const libhqr_tree_t *qrtree,
for (k = 0; k < K; k++) {
RUNTIME_iteration_push(morse, k);
tempkn = k == B->nt-1 ? B->n-k*B->nb : B->nb;
tempkm = k == B->mt-1 ? B->m-k*B->mb : B->mb;
ldak = BLKLDD(A, k);
for (i = 0; i < qrtree->getnbgeqrf(qrtree, k); i++) {
n = qrtree->getm(qrtree, k, i);
m = qrtree->getm(qrtree, k, i);
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
tempkmin = chameleon_min(tempnn, tempkn);
ldan = BLKLDD(A, n);
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
tempkmin = chameleon_min(tempmm, tempkm);
ldbm = BLKLDD(B, m);
#if defined(CHAMELEON_COPY_DIAG)
MORSE_TASK_zlacpy(
&options,
MorseUpper, tempnn, tempkmin, A->nb,
A(n, k), ldan,
D(n, k), ldan );
MorseUpper, tempkmin, tempkmm, A->nb,
A(k, m), ldak,
D(k, m), ldak );
#if defined(CHAMELEON_USE_CUDA)
MORSE_TASK_zlaset(
&options,
MorseLower, tempnn, tempkmin,
MorseLower, tempkmin, tempkmm,
0., 1.,
D(n, k), ldan );
D(k, m), ldak );
#endif
#endif
for (m = 0; m < B->mt; m++) {
ldbm = BLKLDD(B, m);
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
for (n = 0; n < B->nt; n++) {
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
MORSE_TASK_zunmlq(
&options,
side, trans,
tempmm, tempnn, tempkmin, ib, TS->nb,
D( n, k), ldan,
TS(n, k), TS->mb,
D( k, m), ldan,
TS(k, m), TS->mb,
B( m, n), ldbm);
}
}
/* Setting the order of tiles */
libhqr_treewalk(qrtree, k, tiles);
for (i = k; i < B->nt-1; n++) {
n = tiles[i];
p = qrtree->currpiv(qrtree, k, n);
for (i = k; i < B->mt-1; i++) {
m = tiles[i];
p = qrtree->currpiv(qrtree, k, m);
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
ldan = BLKLDD(A, n);
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
ldbm = BLKLDD(B, m);
ldbp = BLKLDD(B, p);
if(qrtree->gettype(qrtree, k, n) == 0){
for (m = 0; m < B->mt; m++) {
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
ldbm = BLKLDD(B, m);
if(qrtree->gettype(qrtree, k, m) == 0){
for (n = 0; n < B->nt; n++) {
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
MORSE_TASK_ztsmlq(
&options,
side, trans,
tempmm, B->nb, tempmm, tempnn, tempkn, ib, TS->nb,
B( m, p), ldbm,
tempmm, B->nb, tempmm, tempnn, tempkm, ib, TS->nb,
B( p, n), ldbp,
B( m, n), ldbm,
A( n, k), ldan,
TS(n, k), TS->mb);
A( k, n), ldak,
TS(k, n), TS->mb);
}
}
else {
for (m = 0; m < B->mt; m++) {
tempmm = m == B->mt-1 ? B->m-m*B->mb : B->mb;
ldbm = BLKLDD(B, m);
for (n = 0; n < B->nt; n++) {
tempnn = n == B->nt-1 ? B->n-n*B->nb : B->nb;
MORSE_TASK_zttmlq(
&options,
side, trans,
tempmm, B->nb, tempmm, tempnn, tempkn, ib, TT->nb,
B( m, p), ldbm,
tempmm, B->nb, tempmm, tempnn, tempkm, ib, TT->nb,
B( p, n), ldbp,
B( m, n), ldbm,
A( n, k), ldan,
TT(n, k), TT->mb);
A( k, n), ldak,
TT(k, n), TT->mb);
}
}
}
......
/**
*
* @copyright (c) 2009-2014 The University of Tennessee and The University
* of Tennessee Research Foundation.
* All rights reserved.
* @copyright (c) 2012-2014 Inria. All rights reserved.
* @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
*
**/
/**
*
* @file zunmlq_param.c
*
* MORSE computational routines
* MORSE is a software package provided by Univ. of Tennessee,
* Univ. of California Berkeley and Univ. of Colorado Denver
*
* @version 2.5.0
* @comment This file has been automatically generated
* from Plasma 2.5.0 for MORSE 1.0.0
* @author Hatem Ltaief
* @author Jakub Kurzak
* @author Dulceneia Becker
* @author Mathieu Faverge
* @author Emmanuel Agullo
* @author Cedric Castagnede
* @date 2010-11-15
* @precisions normal z -> s d c
*
**/
#include "control/common.h"
/**
*******************************************************************************
*
* @ingroup MORSE_Complex64_t
*
* MORSE_zunmlq_param - Overwrites the general complex M-by-N matrix C with
*
* SIDE = 'L' SIDE = 'R'
* TRANS = 'N': Q * C C * Q
* TRANS = 'C': Q**H * C C * Q**H
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
* Q = H(1) H(2) . . . H(k)
*
* as returned by MORSE_zgeqrf. Q is of order M if SIDE = MorseLeft
* and of order N if SIDE = MorseRight.
*
*******************************************************************************
*
* @param[in] side
* Intended usage:
* = MorseLeft: apply Q or Q**H from the left;
* = MorseRight: apply Q or Q**H from the right.
*
* @param[in] trans
* Intended usage:
* = MorseNoTrans: no transpose, apply Q;
* = MorseConjTrans: conjugate transpose, apply Q**H.
*
* @param[in] M
* The number of rows of the matrix C. M >= 0.
*
* @param[in] N
* The number of columns of the matrix C. N >= 0.
*
* @param[in] K
* The number of rows of elementary tile reflectors whose product defines the matrix Q.
* If side == MorseLeft, M >= K >= 0.
* If side == MorseRight, N >= K >= 0.
*
* @param[in] A
* Details of the LQ factorization of the original matrix A as returned by MORSE_zgelqf.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,K).
*
* @param[in] descT
* Auxiliary factorization data, computed by MORSE_zgelqf.
*
* @param[in,out] C
* On entry, the M-by-N matrix C.
* On exit, C is overwritten by Q*C or Q**H*C.
*
* @param[in] LDC
* The leading dimension of the array C. LDC >= max(1,M).
*
*******************************************************************************
*
* @return
* \retval MORSE_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
*
*******************************************************************************
*
* @sa MORSE_zunmlq_param_Tile
* @sa MORSE_zunmlq_param_Tile_Async
* @sa MORSE_cunmlq
* @sa MORSE_dormlq
* @sa MORSE_sormlq
* @sa MORSE_zgelqf
*
******************************************************************************/
int MORSE_zunmlq_param(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, int M, int N, int K,
MORSE_Complex64_t *A, int LDA,
MORSE_desc_t *descTS, MORSE_desc_t *descTT,
MORSE_Complex64_t *C, int LDC)
{
int NB, An;
int status;
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
MORSE_request_t request = MORSE_REQUEST_INITIALIZER;
MORSE_desc_t descA, descC;
morse = morse_context_self();
if (morse == NULL) {
morse_fatal_error("MORSE_zunmlq_param", "MORSE not initialized");
return MORSE_ERR_NOT_INITIALIZED;
}
if (side == MorseLeft)
An = M;
else
An = N;
/* Check input arguments */
if ((side != MorseLeft) && (side != MorseRight)) {
morse_error("MORSE_zunmlq_param", "illegal value of side");
return -1;
}
if ((trans != MorseConjTrans) && (trans != MorseNoTrans)){
morse_error("MORSE_zunmlq_param", "illegal value of trans");
return -2;
}
if (M < 0) {
morse_error("MORSE_zunmlq_param", "illegal value of M");
return -3;
}
if (N < 0) {
morse_error("MORSE_zunmlq_param", "illegal value of N");
return -4;
}
if ((K < 0) || (K > An)) {
morse_error("MORSE_zunmlq_param", "illegal value of K");
return -5;
}
if (LDA < chameleon_max(1, K)) {
morse_error("MORSE_zunmlq_param", "illegal value of LDA");
return -7;
}
if (LDC < chameleon_max(1, M)) {
morse_error("MORSE_zunmlq_param", "illegal value of LDC");
return -10;
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, C, LDC ) */
if (chameleon_min(M, chameleon_min(N, K)) == 0)
return MORSE_SUCCESS;
/* Tune NB & IB depending on M, N & NRHS; Set NBNB */
status = morse_tune(MORSE_FUNC_ZGELS, M, K, N);
if (status != MORSE_SUCCESS) {
morse_error("MORSE_zunmlq_param", "morse_tune() failed");
return status;
}
/* Set MT, NT & NTRHS */
NB = MORSE_NB;
morse_sequence_create(morse, &sequence);
/* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
morse_zooplap2tile( descA, A, NB, NB, LDA, An, 0, 0, K, An, sequence, &request,
morse_desc_mat_free(&(descA)) );
morse_zooplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M, N, sequence, &request,
morse_desc_mat_free(&(descA)); morse_desc_mat_free(&(descC)));
/* } else {*/
/* morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, K, An,*/
/* sequence, &request);*/
/* morse_ziplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M, N,*/
/* sequence, &request);*/
/* }*/
/* Call the tile interface */
MORSE_zunmlq_param_Tile_Async(
qrtree, side, trans, &descA, descTS, descTT, &descC, sequence, &request);
/* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
morse_zooptile2lap(descC, C, NB, NB, LDC, N, sequence, &request);
morse_sequence_wait(morse, sequence);
morse_desc_mat_free(&descA);
morse_desc_mat_free(&descC);
/* } else {*/
/* morse_ziptile2lap( descA, A, NB, NB, LDA, An, sequence, &request);*/
/* morse_ziptile2lap( descC, C, NB, NB, LDC, N, sequence, &request);*/
/* morse_sequence_wait(morse, sequence);*/
/* }*/
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
}
/**
*******************************************************************************
*
* @ingroup MORSE_Complex64_t_Tile
*
* MORSE_zunmlq_param_Tile - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal
* matrix (unitary in the complex case) defined as the product of elementary reflectors returned
* by MORSE_zgelqf_Tile Q is of order M.
* All matrices are passed through descriptors. All dimensions are taken from the descriptors.
*
*******************************************************************************
*
* @param[in] side
* Intended usage:
* = MorseLeft: apply Q or Q**H from the left;
* = MorseRight: apply Q or Q**H from the right.
* Currently only MorseLeft is supported.
*
* @param[in] trans
* Intended usage:
* = MorseNoTrans: no transpose, apply Q;
* = MorseConjTrans: conjugate transpose, apply Q**H.
* Currently only MorseConjTrans is supported.
*
* @param[in] A
* Details of the LQ factorization of the original matrix A as returned by MORSE_zgelqf.
*
* @param[in] T
* Auxiliary factorization data, computed by MORSE_zgelqf.
*
* @param[in,out] C
* On entry, the M-by-N matrix C.
* On exit, C is overwritten by Q*C or Q**H*C.
*
*******************************************************************************
*
* @return
* \retval MORSE_SUCCESS successful exit
*
*******************************************************************************
*
* @sa MORSE_zunmlq_param
* @sa MORSE_zunmlq_param_Tile_Async
* @sa MORSE_cunmlq_Tile
* @sa MORSE_dormlq_Tile
* @sa MORSE_sormlq_Tile
* @sa MORSE_zgelqf_Tile
*
******************************************************************************/
int MORSE_zunmlq_param_Tile(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans,
MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *C)
{
MORSE_context_t *morse;
MORSE_sequence_t *sequence = NULL;
MORSE_request_t request = MORSE_REQUEST_INITIALIZER;
int status;
morse = morse_context_self();
if (morse == NULL) {
morse_fatal_error("MORSE_zunmlq_param_Tile", "MORSE not initialized");
return MORSE_ERR_NOT_INITIALIZED;
}
morse_sequence_create(morse, &sequence);
MORSE_zunmlq_param_Tile_Async(qrtree, side, trans, A, TS, TT, C, sequence, &request);
morse_sequence_wait(morse, sequence);
RUNTIME_desc_getoncpu(A);
RUNTIME_desc_getoncpu(C);
status = sequence->status;
morse_sequence_destroy(morse, sequence);
return status;
}
/**
*******************************************************************************
*
* @ingroup MORSE_Complex64_t_Tile_Async
*
* Non-blocking equivalent of MORSE_zunmlq_param_Tile().
* May return before the computation is finished.
* Allows for pipelining of operations at runtime.
*
*******************************************************************************
*
* @param[in] sequence
* Identifies the sequence of function calls that this call belongs to
* (for completion checks and exception handling purposes).
*
* @param[out] request
* Identifies this function call (for exception handling purposes).
*
*******************************************************************************
*
* @sa MORSE_zunmlq_param
* @sa MORSE_zunmlq_param_Tile
* @sa MORSE_cunmlq_Tile_Async
* @sa MORSE_dormlq_Tile_Async
* @sa MORSE_sormlq_Tile_Async
* @sa MORSE_zgelqf_Tile_Async
*
******************************************************************************/
int MORSE_zunmlq_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans,
MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *C,
MORSE_sequence_t *sequence, MORSE_request_t *request)
{
MORSE_context_t *morse;
morse = morse_context_self();
if (morse == NULL) {
morse_fatal_error("MORSE_zunmlq_param_Tile", "MORSE not initialized");
return MORSE_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
morse_fatal_error("MORSE_zunmlq_param_Tile", "NULL sequence");
return MORSE_ERR_UNALLOCATED;
}
if (request == NULL) {
morse_fatal_error("MORSE_zunmlq_param_Tile", "NULL request");
return MORSE_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == MORSE_SUCCESS)
request->status = MORSE_SUCCESS;
else
return morse_request_fail(sequence, request, MORSE_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (morse_desc_check(A) != MORSE_SUCCESS) {
morse_error("MORSE_zunmlq_param_Tile", "invalid first descriptor");
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
if (morse_desc_check(TS) != MORSE_SUCCESS) {
morse_error("MORSE_zunmlq_param_Tile", "invalid second descriptor");
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
if (morse_desc_check(TT) != MORSE_SUCCESS) {
morse_error("MORSE_zunmlq_param_Tile", "invalid third descriptor");
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
if (morse_desc_check(C) != MORSE_SUCCESS) {
morse_error("MORSE_zunmlq_param_Tile", "invalid fourth descriptor");
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (A->nb != A->mb || C->nb != C->mb) {
morse_error("MORSE_zunmlq_param_Tile", "only square tiles supported");
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
if ((side != MorseLeft) && (side != MorseRight)) {
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
if ((trans != MorseConjTrans) && (trans != MorseNoTrans)){
return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, C, LDC ) */
/*
if (chameleon_min(M, chameleon_min(N, K)) == 0)
return MORSE_SUCCESS;
*/
morse_pzunmlq_param(qrtree, side, trans, A, C, TS, TT, sequence, request);
return MORSE_SUCCESS;
}
......@@ -292,6 +292,9 @@ int MORSE_zgeqrs_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A,
int MORSE_zungqr_param(const libhqr_tree_t *qrtree, int M, int N, int K, MORSE_Complex64_t *A, int LDA, MORSE_desc_t *descTS, MORSE_desc_t *descTT, MORSE_Complex64_t *B, int LDB);
int MORSE_zungqr_param_Tile(const libhqr_tree_t *qrtree, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *B);
int MORSE_zungqr_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *B, MORSE_sequence_t *sequence, MORSE_request_t *request);
int MORSE_zunmlq_param(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, int M, int N, int K, MORSE_Complex64_t *A, int LDA, MORSE_desc_t *descT, MORSE_desc_t *TT, MORSE_Complex64_t *B, int LDB);
int MORSE_zunmlq_param_Tile(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *B);
int MORSE_zunmlq_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *B, MORSE_sequence_t *sequence, MORSE_request_t *request);
int MORSE_zunmqr_param(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, int M, int N, int K, MORSE_Complex64_t *A, int LDA, MORSE_desc_t *descTS, MORSE_desc_t *TT, MORSE_Complex64_t *B, int LDB);
int MORSE_zunmqr_param_Tile(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *B);
int MORSE_zunmqr_param_Tile_Async(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum trans, MORSE_desc_t *A, MORSE_desc_t *TS, MORSE_desc_t *TT, MORSE_desc_t *B, MORSE_sequence_t *sequence, MORSE_request_t *request);
......
......@@ -293,7 +293,7 @@ int testing_zgels_param(int argc, char **argv)
MORSE_zgelqf_param(&qrtree, M, N, A2, LDA, TS, TT);
MORSE_ztrsm(MorseLeft, MorseLower, MorseNoTrans, MorseNonUnit, M, NRHS, 1.0, A2, LDA, B2, LDB);
MORSE_zunglq(M, N, K, A2, LDA, TS, Q, LDA);
MORSE_zunmlq(MorseLeft, MorseConjTrans, N, NRHS, M, A2, LDA, TS, B2, LDB);
MORSE_zunmlq_param(&qrtree, MorseLeft, MorseConjTrans, N, NRHS, M, A2, LDA, TS, TT, B2, LDB);
}
/* Check the orthogonality, factorization and the solution */
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment