--- name: "tzrzf" 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/tzrzf" --- # tzrzf(3) tzrzf: RZ factor ## NAME tzrzf - tzrzf: RZ factor ## SYNOPSIS ### Functions subroutine **ctzrzf** (m, n, a, lda, tau, work, lwork, info)\ **CTZRZF** subroutine **dtzrzf** (m, n, a, lda, tau, work, lwork, info)\ **DTZRZF** subroutine **stzrzf** (m, n, a, lda, tau, work, lwork, info)\ **STZRZF** subroutine **ztzrzf** (m, n, a, lda, tau, work, lwork, info)\ **ZTZRZF** ## Detailed Description ## Function Documentation ### subroutine ctzrzf (integer m, integer n, complex, dimension( lda, \* ) a, integer lda, complex, dimension( \* ) tau, complex, dimension( \* ) work, integer lwork, integer info) **CTZRZF** **Purpose:** ``` !> !> CTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A !> to upper triangular form by means of unitary transformations. !> !> The upper trapezoidal matrix A is factored as !> !> A = ( R 0 ) * Z, !> !> where Z is an N-by-N unitary matrix and R is an M-by-M upper !> triangular matrix. !> ``` **Parameters** *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix A. N >= M. !> ``` *A* ``` !> A is COMPLEX array, dimension (LDA,N) !> On entry, the leading M-by-N upper trapezoidal part of the !> array A must contain the matrix to be factorized. !> On exit, the leading M-by-M upper triangular part of A !> contains the upper triangular matrix R, and elements M+1 to !> N of the first M rows of A, with the array TAU, represent the !> unitary matrix Z as a product of M elementary reflectors. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *TAU* ``` !> TAU is COMPLEX array, dimension (M) !> The scalar factors of the elementary reflectors. !> ``` *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. LWORK >= max(1,M). !> For optimum performance LWORK >= M*NB, 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. **Contributors:** A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA **Further Details:** ``` !> !> The N-by-N matrix Z can be computed by !> !> Z = Z(1)*Z(2)* ... *Z(M) !> !> where each N-by-N Z(k) is given by !> !> Z(k) = I - tau(k)*v(k)*v(k)**H !> !> with v(k) is the kth row vector of the M-by-N matrix !> !> V = ( I A(:,M+1:N) ) !> !> I is the M-by-M identity matrix, A(:,M+1:N) !> is the output stored in A on exit from CTZRZF, !> and tau(k) is the kth element of the array TAU. !> !> ``` Definition at line **150** of file **ctzrzf.f**. ### subroutine dtzrzf (integer m, integer n, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( \* ) tau, double precision, dimension( \* ) work, integer lwork, integer info) **DTZRZF** **Purpose:** ``` !> !> DTZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A !> to upper triangular form by means of orthogonal transformations. !> !> The upper trapezoidal matrix A is factored as !> !> A = ( R 0 ) * Z, !> !> where Z is an N-by-N orthogonal matrix and R is an M-by-M upper !> triangular matrix. !> ``` **Parameters** *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix A. N >= M. !> ``` *A* ``` !> A is DOUBLE PRECISION array, dimension (LDA,N) !> On entry, the leading M-by-N upper trapezoidal part of the !> array A must contain the matrix to be factorized. !> On exit, the leading M-by-M upper triangular part of A !> contains the upper triangular matrix R, and elements M+1 to !> N of the first M rows of A, with the array TAU, represent the !> orthogonal matrix Z as a product of M elementary reflectors. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *TAU* ``` !> TAU is DOUBLE PRECISION array, dimension (M) !> The scalar factors of the elementary reflectors. !> ``` *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. LWORK >= max(1,M). !> For optimum performance LWORK >= M*NB, 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. **Contributors:** A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA **Further Details:** ``` !> !> The N-by-N matrix Z can be computed by !> !> Z = Z(1)*Z(2)* ... *Z(M) !> !> where each N-by-N Z(k) is given by !> !> Z(k) = I - tau(k)*v(k)*v(k)**T !> !> with v(k) is the kth row vector of the M-by-N matrix !> !> V = ( I A(:,M+1:N) ) !> !> I is the M-by-M identity matrix, A(:,M+1:N) !> is the output stored in A on exit from DTZRZF, !> and tau(k) is the kth element of the array TAU. !> !> ``` Definition at line **150** of file **dtzrzf.f**. ### subroutine stzrzf (integer m, integer n, real, dimension( lda, \* ) a, integer lda, real, dimension( \* ) tau, real, dimension( \* ) work, integer lwork, integer info) **STZRZF** **Purpose:** ``` !> !> STZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A !> to upper triangular form by means of orthogonal transformations. !> !> The upper trapezoidal matrix A is factored as !> !> A = ( R 0 ) * Z, !> !> where Z is an N-by-N orthogonal matrix and R is an M-by-M upper !> triangular matrix. !> ``` **Parameters** *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix A. N >= M. !> ``` *A* ``` !> A is REAL array, dimension (LDA,N) !> On entry, the leading M-by-N upper trapezoidal part of the !> array A must contain the matrix to be factorized. !> On exit, the leading M-by-M upper triangular part of A !> contains the upper triangular matrix R, and elements M+1 to !> N of the first M rows of A, with the array TAU, represent the !> orthogonal matrix Z as a product of M elementary reflectors. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *TAU* ``` !> TAU is REAL array, dimension (M) !> The scalar factors of the elementary reflectors. !> ``` *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. LWORK >= max(1,M). !> For optimum performance LWORK >= M*NB, 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. **Contributors:** A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA **Further Details:** ``` !> !> The N-by-N matrix Z can be computed by !> !> Z = Z(1)*Z(2)* ... *Z(M) !> !> where each N-by-N Z(k) is given by !> !> Z(k) = I - tau(k)*v(k)*v(k)**T !> !> with v(k) is the kth row vector of the M-by-N matrix !> !> V = ( I A(:,M+1:N) ) !> !> I is the M-by-M identity matrix, A(:,M+1:N) !> is the output stored in A on exit from STZRZF, !> and tau(k) is the kth element of the array TAU. !> !> ``` Definition at line **150** of file **stzrzf.f**. ### subroutine ztzrzf (integer m, integer n, complex\*16, dimension( lda, \* ) a, integer lda, complex\*16, dimension( \* ) tau, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZTZRZF** **Purpose:** ``` !> !> ZTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A !> to upper triangular form by means of unitary transformations. !> !> The upper trapezoidal matrix A is factored as !> !> A = ( R 0 ) * Z, !> !> where Z is an N-by-N unitary matrix and R is an M-by-M upper !> triangular matrix. !> ``` **Parameters** *M* ``` !> M is INTEGER !> The number of rows of the matrix A. M >= 0. !> ``` *N* ``` !> N is INTEGER !> The number of columns of the matrix A. N >= M. !> ``` *A* ``` !> A is COMPLEX*16 array, dimension (LDA,N) !> On entry, the leading M-by-N upper trapezoidal part of the !> array A must contain the matrix to be factorized. !> On exit, the leading M-by-M upper triangular part of A !> contains the upper triangular matrix R, and elements M+1 to !> N of the first M rows of A, with the array TAU, represent the !> unitary matrix Z as a product of M elementary reflectors. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *TAU* ``` !> TAU is COMPLEX*16 array, dimension (M) !> The scalar factors of the elementary reflectors. !> ``` *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. LWORK >= max(1,M). !> For optimum performance LWORK >= M*NB, 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. **Contributors:** A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA **Further Details:** ``` !> !> The N-by-N matrix Z can be computed by !> !> Z = Z(1)*Z(2)* ... *Z(M) !> !> where each N-by-N Z(k) is given by !> !> Z(k) = I - tau(k)*v(k)*v(k)**H !> !> with v(k) is the kth row vector of the M-by-N matrix !> !> V = ( I A(:,M+1:N) ) !> !> I is the M-by-M identity matrix, A(:,M+1:N) !> is the output stored in A on exit from ZTZRZF, !> and tau(k) is the kth element of the array TAU. !> !> ``` Definition at line **150** of file **ztzrzf.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.