Loading...
Searching...
No Matches
laswp: Swap rows
Dense LA » Linear system solvers » General matrices: LU » Auxiliary routines

## Functions

void | magmablas_claswp (magma_int_t n, magmaFloatComplex_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_claswpx (magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldx, magma_int_t ldy, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_claswp2 (magma_int_t n, magmaFloatComplex_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_dlaswp (magma_int_t n, magmaDouble_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_dlaswpx (magma_int_t n, magmaDouble_ptr dA, magma_int_t ldx, magma_int_t ldy, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_dlaswp2 (magma_int_t n, magmaDouble_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_dslaswp (magma_int_t n, magmaDouble_ptr A, magma_int_t lda, magmaFloat_ptr SA, magma_int_t ldsa, magma_int_t m, const magma_int_t *ipiv, magma_int_t incx, magma_queue_t queue)
| Row i of A is cast to single precision in row ipiv[i] of SA (incx > 0), or row i of SA is cast to double precision in row ipiv[i] of A (incx < 0), for 0 <= i < M.
void | magmablas_hlaswp (magma_int_t n, magmaHalf *dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_hlaswp2 (magma_int_t n, magmaHalf *dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_slaswp (magma_int_t n, magmaFloat_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_slaswpx (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldx, magma_int_t ldy, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_slaswp2 (magma_int_t n, magmaFloat_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_zclaswp (magma_int_t n, magmaDoubleComplex_ptr A, magma_int_t lda, magmaFloatComplex_ptr SA, magma_int_t ldsa, magma_int_t m, const magma_int_t *ipiv, magma_int_t incx, magma_queue_t queue)
| Row i of A is cast to single precision in row ipiv[i] of SA (incx > 0), or row i of SA is cast to double precision in row ipiv[i] of A (incx < 0), for 0 <= i < M.
void | magmablas_zlaswp (magma_int_t n, magmaDoubleComplex_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_zlaswpx (magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldx, magma_int_t ldy, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue)
void | magmablas_zlaswp2 (magma_int_t n, magmaDoubleComplex_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci, magma_queue_t queue)

## Detailed Description

## Function Documentation

## magmablas_claswp()

void magmablas_claswp | ( | magma_int_t | n,
|  | magmaFloatComplex_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

CLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | COMPLEX array on GPU, stored row-wise, dimension (LDDA,M) The M-by-N matrix, stored transposed as N-by-M matrix embedded in LDDA-by-M array. M is not given; it is implicit. On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. ldda >= n.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, INCI > 0. TODO: If INCI is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_claswpx()

void magmablas_claswpx | ( | magma_int_t | n,
|  | magmaFloatComplex_ptr | dA,
|  | magma_int_t | ldx,
|  | magma_int_t | ldy,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

CLASWPX performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored either row-wise or column-wise, depending on ldx and ldy. ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dA | COMPLEX array on GPU, dimension (,) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldx | INTEGER Stride between elements in same column.
  [in] | ldy | INTEGER Stride between elements in same row. For A stored row-wise, set ldx=ldda and ldy=1. For A stored column-wise, set ldx=1 and ldy=ldda.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_claswp2()

void magmablas_claswp2 | ( | magma_int_t | n,
|  | magmaFloatComplex_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | magmaInt_const_ptr | d_ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

CLASWP2 performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

Here, d_ipiv is passed in GPU memory.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | COMPLEX array on GPU, stored row-wise, dimension (LDDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. (I.e., stride between elements in a column.)
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | d_ipiv | INTEGER array, on GPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dlaswp()

void magmablas_dlaswp | ( | magma_int_t | n,
|  | magmaDouble_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

DLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | DOUBLE PRECISION array on GPU, stored row-wise, dimension (LDDA,M) The M-by-N matrix, stored transposed as N-by-M matrix embedded in LDDA-by-M array. M is not given; it is implicit. On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. ldda >= n.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, INCI > 0. TODO: If INCI is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dlaswpx()

void magmablas_dlaswpx | ( | magma_int_t | n,
|  | magmaDouble_ptr | dA,
|  | magma_int_t | ldx,
|  | magma_int_t | ldy,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

DLASWPX performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored either row-wise or column-wise, depending on ldx and ldy. ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dA | DOUBLE PRECISION array on GPU, dimension (,) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldx | INTEGER Stride between elements in same column.
  [in] | ldy | INTEGER Stride between elements in same row. For A stored row-wise, set ldx=ldda and ldy=1. For A stored column-wise, set ldx=1 and ldy=ldda.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dlaswp2()

void magmablas_dlaswp2 | ( | magma_int_t | n,
|  | magmaDouble_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | magmaInt_const_ptr | d_ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

DLASWP2 performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

Here, d_ipiv is passed in GPU memory.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | DOUBLE PRECISION array on GPU, stored row-wise, dimension (LDDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. (I.e., stride between elements in a column.)
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | d_ipiv | INTEGER array, on GPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dslaswp()

void magmablas_dslaswp | ( | magma_int_t | n,
|  | magmaDouble_ptr | A,
|  | magma_int_t | lda,
|  | magmaFloat_ptr | SA,
|  | magma_int_t | ldsa,
|  | magma_int_t | m,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | incx,
|  | magma_queue_t | queue )

Row i of A is cast to single precision in row ipiv[i] of SA (incx > 0), or row i of SA is cast to double precision in row ipiv[i] of A (incx < 0), for 0 <= i < M.

Parameters

  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix A.
  [in,out] | A | DOUBLE PRECISION array on the GPU, dimension (LDA,N) On entry, the M-by-N matrix to which the row interchanges will be applied. TODO update docs
  [in] | lda | INTEGER. LDA specifies the leading dimension of A.
  [in,out] | SA | REAL array on the GPU, dimension (LDSA,N) On exit, the single precision, permuted matrix. TODO update docs
  [in] | ldsa | INTEGER. LDSA specifies the leading dimension of SA.
  [in] | m | The number of rows to be interchanged.
  [in] | ipiv | INTEGER array on the GPU, dimension (M) The vector of pivot indices. Row i of A is cast to single precision in row ipiv[i] of SA, for 0 <= i < m.
  [in] | incx | INTEGER If INCX is negative, the pivots are applied in reverse order, otherwise in straight-forward order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_hlaswp()

void magmablas_hlaswp | ( | magma_int_t | n,
|  | magmaHalf * | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

HLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | HALF array on GPU, stored row-wise, dimension (LDDA,M) The M-by-N matrix, stored transposed as N-by-M matrix embedded in LDDA-by-M array. M is not given; it is implicit. On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. ldda >= n.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, INCI > 0. TODO: If INCI is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_hlaswp2()

void magmablas_hlaswp2 | ( | magma_int_t | n,
|  | magmaHalf * | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | magmaInt_const_ptr | d_ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

SLASWP2 performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

Here, d_ipiv is passed in GPU memory.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | REAL array on GPU, stored row-wise, dimension (LDDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. (I.e., stride between elements in a column.)
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | d_ipiv | INTEGER array, on GPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_slaswp()

void magmablas_slaswp | ( | magma_int_t | n,
|  | magmaFloat_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

SLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | REAL array on GPU, stored row-wise, dimension (LDDA,M) The M-by-N matrix, stored transposed as N-by-M matrix embedded in LDDA-by-M array. M is not given; it is implicit. On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. ldda >= n.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, INCI > 0. TODO: If INCI is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_slaswpx()

void magmablas_slaswpx | ( | magma_int_t | n,
|  | magmaFloat_ptr | dA,
|  | magma_int_t | ldx,
|  | magma_int_t | ldy,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

SLASWPX performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored either row-wise or column-wise, depending on ldx and ldy. ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dA | REAL array on GPU, dimension (,) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldx | INTEGER Stride between elements in same column.
  [in] | ldy | INTEGER Stride between elements in same row. For A stored row-wise, set ldx=ldda and ldy=1. For A stored column-wise, set ldx=1 and ldy=ldda.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_slaswp2()

void magmablas_slaswp2 | ( | magma_int_t | n,
|  | magmaFloat_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | magmaInt_const_ptr | d_ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

SLASWP2 performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

Here, d_ipiv is passed in GPU memory.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | REAL array on GPU, stored row-wise, dimension (LDDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. (I.e., stride between elements in a column.)
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | d_ipiv | INTEGER array, on GPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zclaswp()

void magmablas_zclaswp | ( | magma_int_t | n,
|  | magmaDoubleComplex_ptr | A,
|  | magma_int_t | lda,
|  | magmaFloatComplex_ptr | SA,
|  | magma_int_t | ldsa,
|  | magma_int_t | m,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | incx,
|  | magma_queue_t | queue )

Row i of A is cast to single precision in row ipiv[i] of SA (incx > 0), or row i of SA is cast to double precision in row ipiv[i] of A (incx < 0), for 0 <= i < M.

Parameters

  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix A.
  [in,out] | A | DOUBLE PRECISION array on the GPU, dimension (LDA,N) On entry, the M-by-N matrix to which the row interchanges will be applied. TODO update docs
  [in] | lda | INTEGER. LDA specifies the leading dimension of A.
  [in,out] | SA | REAL array on the GPU, dimension (LDSA,N) On exit, the single precision, permuted matrix. TODO update docs
  [in] | ldsa | INTEGER. LDSA specifies the leading dimension of SA.
  [in] | m | The number of rows to be interchanged.
  [in] | ipiv | INTEGER array on the GPU, dimension (M) The vector of pivot indices. Row i of A is cast to single precision in row ipiv[i] of SA, for 0 <= i < m.
  [in] | incx | INTEGER If INCX is negative, the pivots are applied in reverse order, otherwise in straight-forward order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zlaswp()

void magmablas_zlaswp | ( | magma_int_t | n,
|  | magmaDoubleComplex_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

ZLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | COMPLEX*16 array on GPU, stored row-wise, dimension (LDDA,M) The M-by-N matrix, stored transposed as N-by-M matrix embedded in LDDA-by-M array. M is not given; it is implicit. On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. ldda >= n.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, INCI > 0. TODO: If INCI is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zlaswpx()

void magmablas_zlaswpx | ( | magma_int_t | n,
|  | magmaDoubleComplex_ptr | dA,
|  | magma_int_t | ldx,
|  | magma_int_t | ldy,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | const magma_int_t * | ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

ZLASWPX performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored either row-wise or column-wise, depending on ldx and ldy. ** Otherwise, this is identical to LAPACK's interface.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dA | COMPLEX*16 array on GPU, dimension (,) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldx | INTEGER Stride between elements in same column.
  [in] | ldy | INTEGER Stride between elements in same row. For A stored row-wise, set ldx=ldda and ldy=1. For A stored column-wise, set ldx=1 and ldy=ldda.
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zlaswp2()

void magmablas_zlaswp2 | ( | magma_int_t | n,
|  | magmaDoubleComplex_ptr | dAT,
|  | magma_int_t | ldda,
|  | magma_int_t | k1,
|  | magma_int_t | k2,
|  | magmaInt_const_ptr | d_ipiv,
|  | magma_int_t | inci,
|  | magma_queue_t | queue )

# Purpose:

ZLASWP2 performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.

Here, d_ipiv is passed in GPU memory.

# Arguments:

Parameters

  [in] | n | INTEGER The number of columns of the matrix A.
  [in,out] | dAT | COMPLEX*16 array on GPU, stored row-wise, dimension (LDDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
  [in] | ldda | INTEGER The leading dimension of the array A. (I.e., stride between elements in a column.)
  [in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.)
  [in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.)
  [in] | d_ipiv | INTEGER array, on GPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged.
  [in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order.
  [in] | queue | magma_queue_t Queue to execute in.