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

\(B = A\) More...

## Functions

void | magmablas_clacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex_const_ptr const dAarray[], magma_int_t ldda, magmaFloatComplex_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue)
| CLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_clacpy_vbatched (magma_uplo_t uplo, magma_int_t max_m, magma_int_t max_n, magma_int_t *m, magma_int_t *n, magmaFloatComplex const *const *dAarray, magma_int_t *ldda, magmaFloatComplex **dBarray, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
| CLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_dlacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDouble_const_ptr const dAarray[], magma_int_t ldda, magmaDouble_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue)
| DLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_dlacpy_vbatched (magma_uplo_t uplo, magma_int_t max_m, magma_int_t max_n, magma_int_t *m, magma_int_t *n, double const *const *dAarray, magma_int_t *ldda, double **dBarray, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
| DLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_slacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloat_const_ptr const dAarray[], magma_int_t ldda, magmaFloat_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue)
| SLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_slacpy_vbatched (magma_uplo_t uplo, magma_int_t max_m, magma_int_t max_n, magma_int_t *m, magma_int_t *n, float const *const *dAarray, magma_int_t *ldda, float **dBarray, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
| SLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_zlacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDoubleComplex_const_ptr const dAarray[], magma_int_t ldda, magmaDoubleComplex_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue)
| ZLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
void | magmablas_zlacpy_vbatched (magma_uplo_t uplo, magma_int_t max_m, magma_int_t max_n, magma_int_t *m, magma_int_t *n, magmaDoubleComplex const *const *dAarray, magma_int_t *ldda, magmaDoubleComplex **dBarray, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
| ZLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

## Detailed Description

\(B = A\)

## Function Documentation

## magmablas_clacpy_batched()

void magmablas_clacpy_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex_const_ptr const | dAarray[],
|  | magma_int_t | ldda,
|  | magmaFloatComplex_ptr | dBarray[],
|  | magma_int_t | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | m | INTEGER The number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | COMPLEX* array, dimension (batchCount) Array of pointers to the matrices dA, where each dA is of dimension (LDDA,N). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,M).
  [out] | dBarray | COMPLEX* array, dimension (batchCount) Array of pointers to the matrices dB, where each dB is of dimension (LDDB,N). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER The leading dimension of each array dB. LDDB >= max(1,M).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_clacpy_vbatched()

void magmablas_clacpy_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t | max_m,
|  | magma_int_t | max_n,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magmaFloatComplex const *const * | dAarray,
|  | magma_int_t * | ldda,
|  | magmaFloatComplex ** | dBarray,
|  | magma_int_t * | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Matrices are assumed to generally have different sizes/leading dimensions

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | max_m | INTEGER. maximum value of m.
  [in] | max_n | INTEGER. maximum value of n.
  [in] | m | INTEGER array, dimension (batchCount). Each is the number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER array, dimension (batchCount). The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | Array of pointers , dimension (batchCount) Each is a COMPLEX array dA, where the ith matrix dA is of dimension (ldda[i],n[i]). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dA. For the ith matrix dA ldda[i] >= max(1,m[i]).
  [out] | dBarray | Array of pointers, dimension(batchCount). Each is a COMPLEX array dB, where the ith matrix dB is of dimension (lddb[i],n[i]). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dB. For the ith matrix dB lddb[i] >= max(1,m[i]).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dlacpy_batched()

void magmablas_dlacpy_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDouble_const_ptr const | dAarray[],
|  | magma_int_t | ldda,
|  | magmaDouble_ptr | dBarray[],
|  | magma_int_t | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | m | INTEGER The number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | DOUBLE PRECISION* array, dimension (batchCount) Array of pointers to the matrices dA, where each dA is of dimension (LDDA,N). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,M).
  [out] | dBarray | DOUBLE PRECISION* array, dimension (batchCount) Array of pointers to the matrices dB, where each dB is of dimension (LDDB,N). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER The leading dimension of each array dB. LDDB >= max(1,M).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dlacpy_vbatched()

void magmablas_dlacpy_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t | max_m,
|  | magma_int_t | max_n,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | double const *const * | dAarray,
|  | magma_int_t * | ldda,
|  | double ** | dBarray,
|  | magma_int_t * | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Matrices are assumed to generally have different sizes/leading dimensions

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | max_m | INTEGER. maximum value of m.
  [in] | max_n | INTEGER. maximum value of n.
  [in] | m | INTEGER array, dimension (batchCount). Each is the number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER array, dimension (batchCount). The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | Array of pointers , dimension (batchCount) Each is a DOUBLE PRECISION array dA, where the ith matrix dA is of dimension (ldda[i],n[i]). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dA. For the ith matrix dA ldda[i] >= max(1,m[i]).
  [out] | dBarray | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array dB, where the ith matrix dB is of dimension (lddb[i],n[i]). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dB. For the ith matrix dB lddb[i] >= max(1,m[i]).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_slacpy_batched()

void magmablas_slacpy_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloat_const_ptr const | dAarray[],
|  | magma_int_t | ldda,
|  | magmaFloat_ptr | dBarray[],
|  | magma_int_t | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | m | INTEGER The number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | REAL* array, dimension (batchCount) Array of pointers to the matrices dA, where each dA is of dimension (LDDA,N). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,M).
  [out] | dBarray | REAL* array, dimension (batchCount) Array of pointers to the matrices dB, where each dB is of dimension (LDDB,N). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER The leading dimension of each array dB. LDDB >= max(1,M).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_slacpy_vbatched()

void magmablas_slacpy_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t | max_m,
|  | magma_int_t | max_n,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | float const *const * | dAarray,
|  | magma_int_t * | ldda,
|  | float ** | dBarray,
|  | magma_int_t * | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Matrices are assumed to generally have different sizes/leading dimensions

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | max_m | INTEGER. maximum value of m.
  [in] | max_n | INTEGER. maximum value of n.
  [in] | m | INTEGER array, dimension (batchCount). Each is the number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER array, dimension (batchCount). The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | Array of pointers , dimension (batchCount) Each is a REAL array dA, where the ith matrix dA is of dimension (ldda[i],n[i]). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dA. For the ith matrix dA ldda[i] >= max(1,m[i]).
  [out] | dBarray | Array of pointers, dimension(batchCount). Each is a REAL array dB, where the ith matrix dB is of dimension (lddb[i],n[i]). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dB. For the ith matrix dB lddb[i] >= max(1,m[i]).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zlacpy_batched()

void magmablas_zlacpy_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex_const_ptr const | dAarray[],
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_ptr | dBarray[],
|  | magma_int_t | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | m | INTEGER The number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | COMPLEX_16* array, dimension (batchCount) Array of pointers to the matrices dA, where each dA is of dimension (LDDA,N). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,M).
  [out] | dBarray | COMPLEX_16* array, dimension (batchCount) Array of pointers to the matrices dB, where each dB is of dimension (LDDB,N). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER The leading dimension of each array dB. LDDB >= max(1,M).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zlacpy_vbatched()

void magmablas_zlacpy_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t | max_m,
|  | magma_int_t | max_n,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magmaDoubleComplex const *const * | dAarray,
|  | magma_int_t * | ldda,
|  | magmaDoubleComplex ** | dBarray,
|  | magma_int_t * | lddb,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZLACPY_VBATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.

Matrices are assumed to generally have different sizes/leading dimensions

Parameters

  [in]

  uplo

  magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
  - = MagmaUpper: Upper triangular part
  - = MagmaLower: Lower triangular part Otherwise: All of each matrix dA

  [in] | max_m | INTEGER. maximum value of m.
  [in] | max_n | INTEGER. maximum value of n.
  [in] | m | INTEGER array, dimension (batchCount). Each is the number of rows of each matrix dA. M >= 0.
  [in] | n | INTEGER array, dimension (batchCount). The number of columns of each matrix dA. N >= 0.
  [in] | dAarray | Array of pointers , dimension (batchCount) Each is a COMPLEX_16 array dA, where the ith matrix dA is of dimension (ldda[i],n[i]). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed.
  [in] | ldda | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dA. For the ith matrix dA ldda[i] >= max(1,m[i]).
  [out] | dBarray | Array of pointers, dimension(batchCount). Each is a COMPLEX_16 array dB, where the ith matrix dB is of dimension (lddb[i],n[i]). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO.
  [in] | lddb | INTEGER array, dimension (batchCount). Each is the leading dimension of each array dB. For the ith matrix dB lddb[i] >= max(1,m[i]).
  [in] | batchCount | Number of matrices in dAarray and dBarray.
  [in] | queue | magma_queue_t Queue to execute in.