Loading...
Searching...
No Matches
transpose: Transpose matrix
Dense LA » MAGMA BLAS and Auxiliary » Level 2: matrix-vector operations, O(n^2) work

\(B = A^T\) or \(B = A^H\) More...

## Functions

void | magmablas_cgeam (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex beta, magmaFloatComplex_const_ptr dB, magma_int_t lddb, magmaFloatComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| cgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).
void | magmablas_ctranspose (magma_int_t m, magma_int_t n, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dAT, magma_int_t lddat, magma_queue_t queue)
| ctranspose copies and transposes a matrix dA to matrix dAT.
void | magmablas_ctranspose_conj (magma_int_t m, magma_int_t n, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dAT, magma_int_t lddat, magma_queue_t queue)
| ctranspose_conj_q copies and conjugate-transposes a matrix dA to matrix dAT.
void | magmablas_ctranspose_conj_inplace (magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, magma_queue_t queue)
| ctranspose_conj_inplace_q conjugate-transposes a square N-by-N matrix in-place.
void | magmablas_ctranspose_inplace (magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, magma_queue_t queue)
| ctranspose_inplace_q transposes a square N-by-N matrix in-place.
void | magmablas_dgeam (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, double alpha, magmaDouble_const_ptr dA, magma_int_t ldda, double beta, magmaDouble_const_ptr dB, magma_int_t lddb, magmaDouble_ptr dC, magma_int_t lddc, magma_queue_t queue)
| dgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).
void | magmablas_dtranspose (magma_int_t m, magma_int_t n, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_ptr dAT, magma_int_t lddat, magma_queue_t queue)
| dtranspose copies and transposes a matrix dA to matrix dAT.
void | magmablas_dtranspose_inplace (magma_int_t n, magmaDouble_ptr dA, magma_int_t ldda, magma_queue_t queue)
| dtranspose_inplace_q transposes a square N-by-N matrix in-place.
void | magmablas_sgeam (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, float beta, magmaFloat_const_ptr dB, magma_int_t lddb, magmaFloat_ptr dC, magma_int_t lddc, magma_queue_t queue)
| sgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).
void | magmablas_stranspose (magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dAT, magma_int_t lddat, magma_queue_t queue)
| stranspose copies and transposes a matrix dA to matrix dAT.
void | magmablas_stranspose_inplace (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue)
| stranspose_inplace_q transposes a square N-by-N matrix in-place.
void | magmablas_zgeam (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex beta, magmaDoubleComplex_const_ptr dB, magma_int_t lddb, magmaDoubleComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| zgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).
void | magmablas_ztranspose (magma_int_t m, magma_int_t n, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dAT, magma_int_t lddat, magma_queue_t queue)
| ztranspose copies and transposes a matrix dA to matrix dAT.
void | magmablas_ztranspose_conj (magma_int_t m, magma_int_t n, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dAT, magma_int_t lddat, magma_queue_t queue)
| ztranspose_conj_q copies and conjugate-transposes a matrix dA to matrix dAT.
void | magmablas_ztranspose_conj_inplace (magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magma_queue_t queue)
| ztranspose_conj_inplace_q conjugate-transposes a square N-by-N matrix in-place.
void | magmablas_ztranspose_inplace (magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magma_queue_t queue)
| ztranspose_inplace_q transposes a square N-by-N matrix in-place.

## Detailed Description

\(B = A^T\) or \(B = A^H\)

## Function Documentation

## magmablas_cgeam()

void magmablas_cgeam | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloatComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

cgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).

The operation supports also the following in-place transformations C = alpha*C + beta*op( B ) C = alpha*op( A ) + beta*C

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER The number of rows of the matrix op( dA ). M >= 0.
  [in] | n | INTEGER The number of columns of the matrix op( dA ). N >= 0.
  [in] | alpha | COMPLEX On entry, ALPHA specifies the scalar alpha.
  [in] | dA | COMPLEX array, dimension (LDDA,k), where k is N when transA = MagmaNoTrans, and is M otherwise.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N when transA = MagmaNoTrans, and LDDA >= M otherwise.
  [in] | beta | COMPLEX On entry, BETA specifies the scalar beta.
  [in] | dB | COMPLEX array, dimension (LDDB,k), where k is N when transB = MagmaNoTrans, and is M otherwise.
  [in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= N when transB = MagmaNoTrans, and LDDB >= M otherwise.
  [in,out] | dC | COMPLEX array, dimension (LDDC,N). dC can be input, making the operation in-place, if dC is passed as one of the pointers to dA or dB. The M-by-N matrix dC.
  [in] | lddc | INTEGER The leading dimension of the array dC. LDDC >= M.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ctranspose()

void magmablas_ctranspose | ( | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_ptr | dAT,
|  | magma_int_t | lddat,
|  | magma_queue_t | queue )

ctranspose copies and transposes a matrix dA to matrix dAT.

Same as ctranspose, but adds queue argument.

Parameters

  [in] | m | INTEGER The number of rows of the matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX array, dimension (LDDA,N) The M-by-N matrix dA.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M.
  [in] | dAT | COMPLEX array, dimension (LDDAT,M) The N-by-M matrix dAT.
  [in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ctranspose_conj()

void magmablas_ctranspose_conj | ( | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_ptr | dAT,
|  | magma_int_t | lddat,
|  | magma_queue_t | queue )

ctranspose_conj_q copies and conjugate-transposes a matrix dA to matrix dAT.

Same as ctranspose_conj, but adds queue argument.

Parameters

  [in] | m | INTEGER The number of rows of the matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX array, dimension (LDDA,N) The M-by-N matrix dA.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M.
  [in] | dAT | COMPLEX array, dimension (LDDAT,M) The N-by-M matrix dAT.
  [in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ctranspose_conj_inplace()

void magmablas_ctranspose_conj_inplace | ( | magma_int_t | n,
|  | magmaFloatComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magma_queue_t | queue )

ctranspose_conj_inplace_q conjugate-transposes a square N-by-N matrix in-place.

Same as ctranspose_conj_inplace, but adds queue argument.

Parameters

  [in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ctranspose_inplace()

void magmablas_ctranspose_inplace | ( | magma_int_t | n,
|  | magmaFloatComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magma_queue_t | queue )

ctranspose_inplace_q transposes a square N-by-N matrix in-place.

Same as ctranspose_inplace, but adds queue argument.

Parameters

  [in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgeam()

void magmablas_dgeam | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | double | alpha,
|  | magmaDouble_const_ptr | dA,
|  | magma_int_t | ldda,
|  | double | beta,
|  | magmaDouble_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDouble_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

dgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).

The operation supports also the following in-place transformations C = alpha*C + beta*op( B ) C = alpha*op( A ) + beta*C

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER The number of rows of the matrix op( dA ). M >= 0.
  [in] | n | INTEGER The number of columns of the matrix op( dA ). N >= 0.
  [in] | alpha | DOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
  [in] | dA | DOUBLE PRECISION array, dimension (LDDA,k), where k is N when transA = MagmaNoTrans, and is M otherwise.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N when transA = MagmaNoTrans, and LDDA >= M otherwise.
  [in] | beta | DOUBLE PRECISION On entry, BETA specifies the scalar beta.
  [in] | dB | DOUBLE PRECISION array, dimension (LDDB,k), where k is N when transB = MagmaNoTrans, and is M otherwise.
  [in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= N when transB = MagmaNoTrans, and LDDB >= M otherwise.
  [in,out] | dC | DOUBLE PRECISION array, dimension (LDDC,N). dC can be input, making the operation in-place, if dC is passed as one of the pointers to dA or dB. The M-by-N matrix dC.
  [in] | lddc | INTEGER The leading dimension of the array dC. LDDC >= M.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dtranspose()

void magmablas_dtranspose | ( | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDouble_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDouble_ptr | dAT,
|  | magma_int_t | lddat,
|  | magma_queue_t | queue )

dtranspose copies and transposes a matrix dA to matrix dAT.

Same as dtranspose, but adds queue argument.

Parameters

  [in] | m | INTEGER The number of rows of the matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of the matrix dA. N >= 0.
  [in] | dA | DOUBLE PRECISION array, dimension (LDDA,N) The M-by-N matrix dA.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M.
  [in] | dAT | DOUBLE PRECISION array, dimension (LDDAT,M) The N-by-M matrix dAT.
  [in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dtranspose_inplace()

void magmablas_dtranspose_inplace | ( | magma_int_t | n,
|  | magmaDouble_ptr | dA,
|  | magma_int_t | ldda,
|  | magma_queue_t | queue )

dtranspose_inplace_q transposes a square N-by-N matrix in-place.

Same as dtranspose_inplace, but adds queue argument.

Parameters

  [in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0.
  [in] | dA | DOUBLE PRECISION array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgeam()

void magmablas_sgeam | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | float | alpha,
|  | magmaFloat_const_ptr | dA,
|  | magma_int_t | ldda,
|  | float | beta,
|  | magmaFloat_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloat_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

sgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).

The operation supports also the following in-place transformations C = alpha*C + beta*op( B ) C = alpha*op( A ) + beta*C

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER The number of rows of the matrix op( dA ). M >= 0.
  [in] | n | INTEGER The number of columns of the matrix op( dA ). N >= 0.
  [in] | alpha | REAL On entry, ALPHA specifies the scalar alpha.
  [in] | dA | REAL array, dimension (LDDA,k), where k is N when transA = MagmaNoTrans, and is M otherwise.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N when transA = MagmaNoTrans, and LDDA >= M otherwise.
  [in] | beta | REAL On entry, BETA specifies the scalar beta.
  [in] | dB | REAL array, dimension (LDDB,k), where k is N when transB = MagmaNoTrans, and is M otherwise.
  [in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= N when transB = MagmaNoTrans, and LDDB >= M otherwise.
  [in,out] | dC | REAL array, dimension (LDDC,N). dC can be input, making the operation in-place, if dC is passed as one of the pointers to dA or dB. The M-by-N matrix dC.
  [in] | lddc | INTEGER The leading dimension of the array dC. LDDC >= M.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_stranspose()

void magmablas_stranspose | ( | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloat_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloat_ptr | dAT,
|  | magma_int_t | lddat,
|  | magma_queue_t | queue )

stranspose copies and transposes a matrix dA to matrix dAT.

Same as stranspose, but adds queue argument.

Parameters

  [in] | m | INTEGER The number of rows of the matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of the matrix dA. N >= 0.
  [in] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M.
  [in] | dAT | REAL array, dimension (LDDAT,M) The N-by-M matrix dAT.
  [in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_stranspose_inplace()

void magmablas_stranspose_inplace | ( | magma_int_t | n,
|  | magmaFloat_ptr | dA,
|  | magma_int_t | ldda,
|  | magma_queue_t | queue )

stranspose_inplace_q transposes a square N-by-N matrix in-place.

Same as stranspose_inplace, but adds queue argument.

Parameters

  [in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0.
  [in] | dA | REAL array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgeam()

void magmablas_zgeam | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

zgeam adds/transposes matrices: C = alpha*op( A ) + beta*op( B ).

The operation supports also the following in-place transformations C = alpha*C + beta*op( B ) C = alpha*op( A ) + beta*C

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER The number of rows of the matrix op( dA ). M >= 0.
  [in] | n | INTEGER The number of columns of the matrix op( dA ). N >= 0.
  [in] | alpha | COMPLEX_16 On entry, ALPHA specifies the scalar alpha.
  [in] | dA | COMPLEX_16 array, dimension (LDDA,k), where k is N when transA = MagmaNoTrans, and is M otherwise.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N when transA = MagmaNoTrans, and LDDA >= M otherwise.
  [in] | beta | COMPLEX_16 On entry, BETA specifies the scalar beta.
  [in] | dB | COMPLEX_16 array, dimension (LDDB,k), where k is N when transB = MagmaNoTrans, and is M otherwise.
  [in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= N when transB = MagmaNoTrans, and LDDB >= M otherwise.
  [in,out] | dC | COMPLEX_16 array, dimension (LDDC,N). dC can be input, making the operation in-place, if dC is passed as one of the pointers to dA or dB. The M-by-N matrix dC.
  [in] | lddc | INTEGER The leading dimension of the array dC. LDDC >= M.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ztranspose()

void magmablas_ztranspose | ( | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_ptr | dAT,
|  | magma_int_t | lddat,
|  | magma_queue_t | queue )

ztranspose copies and transposes a matrix dA to matrix dAT.

Same as ztranspose, but adds queue argument.

Parameters

  [in] | m | INTEGER The number of rows of the matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX_16 array, dimension (LDDA,N) The M-by-N matrix dA.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M.
  [in] | dAT | COMPLEX_16 array, dimension (LDDAT,M) The N-by-M matrix dAT.
  [in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ztranspose_conj()

void magmablas_ztranspose_conj | ( | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_ptr | dAT,
|  | magma_int_t | lddat,
|  | magma_queue_t | queue )

ztranspose_conj_q copies and conjugate-transposes a matrix dA to matrix dAT.

Same as ztranspose_conj, but adds queue argument.

Parameters

  [in] | m | INTEGER The number of rows of the matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX_16 array, dimension (LDDA,N) The M-by-N matrix dA.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M.
  [in] | dAT | COMPLEX_16 array, dimension (LDDAT,M) The N-by-M matrix dAT.
  [in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ztranspose_conj_inplace()

void magmablas_ztranspose_conj_inplace | ( | magma_int_t | n,
|  | magmaDoubleComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magma_queue_t | queue )

ztranspose_conj_inplace_q conjugate-transposes a square N-by-N matrix in-place.

Same as ztranspose_conj_inplace, but adds queue argument.

Parameters

  [in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX_16 array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ztranspose_inplace()

void magmablas_ztranspose_inplace | ( | magma_int_t | n,
|  | magmaDoubleComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magma_queue_t | queue )

ztranspose_inplace_q transposes a square N-by-N matrix in-place.

Same as ztranspose_inplace, but adds queue argument.

Parameters

  [in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0.
  [in] | dA | COMPLEX_16 array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N.
  [in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N.
  [in] | queue | magma_queue_t Queue to execute in.