--- name: "unmtr" section: "3" platform: "linux" package: "lapack-doc" version: "3.12.1-2" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/unmtr" --- # unmtr(3) {un,or}mtr: multiply by Q from hetrd ## NAME unmtr - {un,or}mtr: multiply by Q from hetrd ## SYNOPSIS ### Functions subroutine **cunmtr** (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)\ **CUNMTR** subroutine **dormtr** (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)\ **DORMTR** subroutine **sormtr** (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)\ **SORMTR** subroutine **zunmtr** (side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)\ **ZUNMTR** ## Detailed Description ## Function Documentation ### subroutine cunmtr (character side, character uplo, character trans, integer m, integer n, complex, dimension( lda, \* ) a, integer lda, complex, dimension( \* ) tau, complex, dimension( ldc, \* ) c, integer ldc, complex, dimension( \* ) work, integer lwork, integer info) **CUNMTR** **Purpose:** ``` !> !> CUNMTR 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 of order nq, with nq = m if !> SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of !> nq-1 elementary reflectors, as returned by CHETRD: !> !> if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); !> !> if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1). !> ``` **Parameters** *SIDE* ``` !> SIDE is CHARACTER*1 !> = 'L': apply Q or Q**H from the Left; !> = 'R': apply Q or Q**H from the Right. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A contains elementary reflectors !> from CHETRD; !> = 'L': Lower triangle of A contains elementary reflectors !> from CHETRD. !> ``` *TRANS* ``` !> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'C': Conjugate transpose, apply Q**H. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix C. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix C. N >= 0. !> ``` *A* ``` !> A is COMPLEX array, dimension !> (LDA,M) if SIDE = 'L' !> (LDA,N) if SIDE = 'R' !> The vectors which define the elementary reflectors, as !> returned by CHETRD. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'. !> ``` *TAU* ``` !> TAU is COMPLEX array, dimension !> (M-1) if SIDE = 'L' !> (N-1) if SIDE = 'R' !> TAU(i) must contain the scalar factor of the elementary !> reflector H(i), as returned by CHETRD. !> ``` *C* ``` !> C is COMPLEX array, dimension (LDC,N) !> On entry, the M-by-N matrix C. !> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q. !> ``` *LDC* ``` !> LDC is INTEGER !> The leading dimension of the array C. LDC >= max(1,M). !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> If SIDE = 'L', LWORK >= max(1,N); !> if SIDE = 'R', LWORK >= max(1,M). !> For optimum performance LWORK >= N*NB if SIDE = 'L', and !> LWORK >=M*NB if SIDE = 'R', where NB is the optimal !> blocksize. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **170** of file **cunmtr.f**. ### subroutine dormtr (character side, character uplo, character trans, integer m, integer n, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( \* ) tau, double precision, dimension( ldc, \* ) c, integer ldc, double precision, dimension( \* ) work, integer lwork, integer info) **DORMTR** **Purpose:** ``` !> !> DORMTR overwrites the general real M-by-N matrix C with !> !> SIDE = 'L' SIDE = 'R' !> TRANS = 'N': Q * C C * Q !> TRANS = 'T': Q**T * C C * Q**T !> !> where Q is a real orthogonal matrix of order nq, with nq = m if !> SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of !> nq-1 elementary reflectors, as returned by DSYTRD: !> !> if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); !> !> if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1). !> ``` **Parameters** *SIDE* ``` !> SIDE is CHARACTER*1 !> = 'L': apply Q or Q**T from the Left; !> = 'R': apply Q or Q**T from the Right. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A contains elementary reflectors !> from DSYTRD; !> = 'L': Lower triangle of A contains elementary reflectors !> from DSYTRD. !> ``` *TRANS* ``` !> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'T': Transpose, apply Q**T. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix C. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix C. N >= 0. !> ``` *A* ``` !> A is DOUBLE PRECISION array, dimension !> (LDA,M) if SIDE = 'L' !> (LDA,N) if SIDE = 'R' !> The vectors which define the elementary reflectors, as !> returned by DSYTRD. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'. !> ``` *TAU* ``` !> TAU is DOUBLE PRECISION array, dimension !> (M-1) if SIDE = 'L' !> (N-1) if SIDE = 'R' !> TAU(i) must contain the scalar factor of the elementary !> reflector H(i), as returned by DSYTRD. !> ``` *C* ``` !> C is DOUBLE PRECISION array, dimension (LDC,N) !> On entry, the M-by-N matrix C. !> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q. !> ``` *LDC* ``` !> LDC is INTEGER !> The leading dimension of the array C. LDC >= max(1,M). !> ``` *WORK* ``` !> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> If SIDE = 'L', LWORK >= max(1,N); !> if SIDE = 'R', LWORK >= max(1,M). !> For optimum performance LWORK >= N*NB if SIDE = 'L', and !> LWORK >= M*NB if SIDE = 'R', where NB is the optimal !> blocksize. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **169** of file **dormtr.f**. ### subroutine sormtr (character side, character uplo, character trans, integer m, integer n, real, dimension( lda, \* ) a, integer lda, real, dimension( \* ) tau, real, dimension( ldc, \* ) c, integer ldc, real, dimension( \* ) work, integer lwork, integer info) **SORMTR** **Purpose:** ``` !> !> SORMTR overwrites the general real M-by-N matrix C with !> !> SIDE = 'L' SIDE = 'R' !> TRANS = 'N': Q * C C * Q !> TRANS = 'T': Q**T * C C * Q**T !> !> where Q is a real orthogonal matrix of order nq, with nq = m if !> SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of !> nq-1 elementary reflectors, as returned by SSYTRD: !> !> if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); !> !> if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1). !> ``` **Parameters** *SIDE* ``` !> SIDE is CHARACTER*1 !> = 'L': apply Q or Q**T from the Left; !> = 'R': apply Q or Q**T from the Right. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A contains elementary reflectors !> from SSYTRD; !> = 'L': Lower triangle of A contains elementary reflectors !> from SSYTRD. !> ``` *TRANS* ``` !> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'T': Transpose, apply Q**T. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix C. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix C. N >= 0. !> ``` *A* ``` !> A is REAL array, dimension !> (LDA,M) if SIDE = 'L' !> (LDA,N) if SIDE = 'R' !> The vectors which define the elementary reflectors, as !> returned by SSYTRD. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'. !> ``` *TAU* ``` !> TAU is REAL array, dimension !> (M-1) if SIDE = 'L' !> (N-1) if SIDE = 'R' !> TAU(i) must contain the scalar factor of the elementary !> reflector H(i), as returned by SSYTRD. !> ``` *C* ``` !> C is REAL array, dimension (LDC,N) !> On entry, the M-by-N matrix C. !> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q. !> ``` *LDC* ``` !> LDC is INTEGER !> The leading dimension of the array C. LDC >= max(1,M). !> ``` *WORK* ``` !> WORK is REAL array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> If SIDE = 'L', LWORK >= max(1,N); !> if SIDE = 'R', LWORK >= max(1,M). !> For optimum performance LWORK >= N*NB if SIDE = 'L', and !> LWORK >= M*NB if SIDE = 'R', where NB is the optimal !> blocksize. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **170** of file **sormtr.f**. ### subroutine zunmtr (character side, character uplo, character trans, integer m, integer n, complex\*16, dimension( lda, \* ) a, integer lda, complex\*16, dimension( \* ) tau, complex\*16, dimension( ldc, \* ) c, integer ldc, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZUNMTR** **Purpose:** ``` !> !> ZUNMTR 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 of order nq, with nq = m if !> SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of !> nq-1 elementary reflectors, as returned by ZHETRD: !> !> if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); !> !> if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1). !> ``` **Parameters** *SIDE* ``` !> SIDE is CHARACTER*1 !> = 'L': apply Q or Q**H from the Left; !> = 'R': apply Q or Q**H from the Right. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangle of A contains elementary reflectors !> from ZHETRD; !> = 'L': Lower triangle of A contains elementary reflectors !> from ZHETRD. !> ``` *TRANS* ``` !> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'C': Conjugate transpose, apply Q**H. !> ``` *M* ``` !> M is INTEGER !> The number of rows of the matrix C. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix C. N >= 0. !> ``` *A* ``` !> A is COMPLEX*16 array, dimension !> (LDA,M) if SIDE = 'L' !> (LDA,N) if SIDE = 'R' !> The vectors which define the elementary reflectors, as !> returned by ZHETRD. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'. !> ``` *TAU* ``` !> TAU is COMPLEX*16 array, dimension !> (M-1) if SIDE = 'L' !> (N-1) if SIDE = 'R' !> TAU(i) must contain the scalar factor of the elementary !> reflector H(i), as returned by ZHETRD. !> ``` *C* ``` !> C is COMPLEX*16 array, dimension (LDC,N) !> On entry, the M-by-N matrix C. !> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q. !> ``` *LDC* ``` !> LDC is INTEGER !> The leading dimension of the array C. LDC >= max(1,M). !> ``` *WORK* ``` !> WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> If SIDE = 'L', LWORK >= max(1,N); !> if SIDE = 'R', LWORK >= max(1,M). !> For optimum performance LWORK >= N*NB if SIDE = 'L', and !> LWORK >=M*NB if SIDE = 'R', where NB is the optimal !> blocksize. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **169** of file **zunmtr.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.