MAGMA  2.0.0
Matrix Algebra for GPU and Multicore Architectures
 All Classes Files Functions Friends Groups Pages
single precision

Functions

void magma_slarfy (magma_int_t n, float *A, magma_int_t lda, const float *V, const float *TAU, float *work)
 magma_slarfy applies an elementary reflector, or Householder matrix, H, to a n-by-n symmetric matrix C, from both the left and the right. More...
 
magma_int_t magma_slarfb_gemm_batched (magma_side_t side, magma_trans_t trans, magma_direct_t direct, magma_storev_t storev, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloat_const_ptr dV_array[], magma_int_t lddv, magmaFloat_const_ptr dT_array[], magma_int_t lddt, magmaFloat_ptr dC_array[], magma_int_t lddc, magmaFloat_ptr dwork_array[], magma_int_t ldwork, magmaFloat_ptr dworkvt_array[], magma_int_t ldworkvt, magma_int_t batchCount, magma_queue_t queue)
 SLARFB applies a real block reflector H or its transpose H^H to a REAL m by n matrix C, from the left. More...
 
magma_int_t magma_slarfb_gpu_q (magma_side_t side, magma_trans_t trans, magma_direct_t direct, magma_storev_t storev, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloat_const_ptr dV, magma_int_t lddv, magmaFloat_const_ptr dT, magma_int_t lddt, magmaFloat_ptr dC, magma_int_t lddc, magmaFloat_ptr dwork, magma_int_t ldwork, magma_queue_t queue)
 SLARFB applies a real block reflector H or its transpose H^H to a REAL m by n matrix C, from the left. More...
 
magma_int_t magma_slarfb_gpu_gemm_q (magma_side_t side, magma_trans_t trans, magma_direct_t direct, magma_storev_t storev, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloat_const_ptr dV, magma_int_t lddv, magmaFloat_const_ptr dT, magma_int_t lddt, magmaFloat_ptr dC, magma_int_t lddc, magmaFloat_ptr dwork, magma_int_t ldwork, magmaFloat_ptr dworkvt, magma_int_t ldworkvt, magma_queue_t queue)
 SLARFB applies a real block reflector H or its transpose H^H to a REAL m by n matrix C, from the left. More...
 

Detailed Description

Function Documentation

magma_int_t magma_slarfb_gemm_batched ( magma_side_t  side,
magma_trans_t  trans,
magma_direct_t  direct,
magma_storev_t  storev,
magma_int_t  m,
magma_int_t  n,
magma_int_t  k,
magmaFloat_const_ptr  dV_array[],
magma_int_t  lddv,
magmaFloat_const_ptr  dT_array[],
magma_int_t  lddt,
magmaFloat_ptr  dC_array[],
magma_int_t  lddc,
magmaFloat_ptr  dwork_array[],
magma_int_t  ldwork,
magmaFloat_ptr  dworkvt_array[],
magma_int_t  ldworkvt,
magma_int_t  batchCount,
magma_queue_t  queue 
)

SLARFB applies a real block reflector H or its transpose H^H to a REAL m by n matrix C, from the left.

Note that this function assumes that the upper part of dV_array is 0 because it is referenced. Same for upper/lower part of dT_array.

Parameters
[in]sidemagma_side_t
  • = MagmaLeft: apply H or H^H from the Left
  • = MagmaRight: apply H or H^H from the Right
[in]transmagma_trans_t
  • = MagmaNoTrans: apply H (No transpose)
  • = MagmaTrans: apply H^H (Conjugate transpose)
[in]directmagma_direct_t Indicates how H is formed from a product of elementary reflectors
  • = MagmaForward: H = H(1) H(2) . . . H(k) (Forward)
  • = MagmaBackward: H = H(k) . . . H(2) H(1) (Backward)
[in]storevmagma_storev_t Indicates how the vectors which define the elementary reflectors are stored:
  • = MagmaColumnwise: Columnwise
  • = MagmaRowwise: Rowwise
[in]mINTEGER The number of rows of the matrix C.
[in]nINTEGER The number of columns of the matrix C.
[in]kINTEGER The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
[in]dV_arrayREAL array on the GPU, dimension (LDDV,K) if STOREV = MagmaColumnwise (LDDV,M) if STOREV = MagmaRowwise and SIDE = MagmaLeft (LDDV,N) if STOREV = MagmaRowwise and SIDE = MagmaRight The matrix V. See further details.
[in]lddvINTEGER The leading dimension of the array V. If STOREV = MagmaColumnwise and SIDE = MagmaLeft, LDDV >= max(1,M); if STOREV = MagmaColumnwise and SIDE = MagmaRight, LDDV >= max(1,N); if STOREV = MagmaRowwise, LDDV >= K.
[in]dT_arrayREAL array on the GPU, dimension (LDDT,K) The triangular k by k matrix T in the representation of the block reflector.
[in]lddtINTEGER The leading dimension of the array T. LDDT >= K.
[in,out]dC_arrayREAL array on the GPU, dimension (LDDC,N) On entry, the m by n matrix C. On exit, C is overwritten by H*C, or H^H*C, or C*H, or C*H^H.
[in]lddcINTEGER The leading dimension of the array C. LDA >= max(1,M).
dwork_array(workspace) REAL array, dimension (LDWORK,K)
[in]ldworkINTEGER The leading dimension of the array WORK. If SIDE = MagmaLeft, LDWORK >= max(1,N); if SIDE = MagmaRight, LDWORK >= max(1,M);
dworkvt_array(workspace) REAL array, dimension (LDWORKT,K)
[in]ldworkvtINTEGER The leading dimension of the array WORKVT. LDWORKVT >= max(1,min(M,N));
[in]batchCountINTEGER The number of matrices to operate on.
[in]queuemagma_queue_t Queue to execute in.

Further Details

The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. All elements including 0's and 1's are stored, unlike LAPACK.

DIRECT = MagmaForward and         DIRECT = MagmaForward and
STOREV = MagmaColumnwise:         STOREV = MagmaRowwise:

         V = (  1  0  0 )                 V = (  1 v1 v1 v1 v1 )
             ( v1  1  0 )                     (  0  1 v2 v2 v2 )
             ( v1 v2  1 )                     (  0  0  1 v3 v3 )
             ( v1 v2 v3 )
             ( v1 v2 v3 )

DIRECT = MagmaBackward and        DIRECT = MagmaBackward and
STOREV = MagmaColumnwise:         STOREV = MagmaRowwise:

         V = ( v1 v2 v3 )                 V = ( v1 v1  1  0  0 )
             ( v1 v2 v3 )                     ( v2 v2 v2  1  0 )
             (  1 v2 v3 )                     ( v3 v3 v3 v3  1 )
             (  0  1 v3 )
             (  0  0  1 )
magma_int_t magma_slarfb_gpu_gemm_q ( magma_side_t  side,
magma_trans_t  trans,
magma_direct_t  direct,
magma_storev_t  storev,
magma_int_t  m,
magma_int_t  n,
magma_int_t  k,
magmaFloat_const_ptr  dV,
magma_int_t  lddv,
magmaFloat_const_ptr  dT,
magma_int_t  lddt,
magmaFloat_ptr  dC,
magma_int_t  lddc,
magmaFloat_ptr  dwork,
magma_int_t  ldwork,
magmaFloat_ptr  dworkvt,
magma_int_t  ldworkvt,
magma_queue_t  queue 
)

SLARFB applies a real block reflector H or its transpose H^H to a REAL m by n matrix C, from the left.

Note that this function assumes that the upper part of dV is 0 because it is referenced. Same for upper/lower part of dT.

Parameters
[in]sidemagma_side_t
  • = MagmaLeft: apply H or H^H from the Left
  • = MagmaRight: apply H or H^H from the Right
[in]transmagma_trans_t
  • = MagmaNoTrans: apply H (No transpose)
  • = MagmaTrans: apply H^H (Conjugate transpose)
[in]directmagma_direct_t Indicates how H is formed from a product of elementary reflectors
  • = MagmaForward: H = H(1) H(2) . . . H(k) (Forward)
  • = MagmaBackward: H = H(k) . . . H(2) H(1) (Backward)
[in]storevmagma_storev_t Indicates how the vectors which define the elementary reflectors are stored:
  • = MagmaColumnwise: Columnwise
  • = MagmaRowwise: Rowwise
[in]mINTEGER The number of rows of the matrix C.
[in]nINTEGER The number of columns of the matrix C.
[in]kINTEGER The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
[in]dVREAL array on the GPU, dimension (LDDV,K) if STOREV = MagmaColumnwise (LDDV,M) if STOREV = MagmaRowwise and SIDE = MagmaLeft (LDDV,N) if STOREV = MagmaRowwise and SIDE = MagmaRight The matrix V. See further details.
[in]lddvINTEGER The leading dimension of the array V. If STOREV = MagmaColumnwise and SIDE = MagmaLeft, LDDV >= max(1,M); if STOREV = MagmaColumnwise and SIDE = MagmaRight, LDDV >= max(1,N); if STOREV = MagmaRowwise, LDDV >= K.
[in]dTREAL array on the GPU, dimension (LDDT,K) The triangular k by k matrix T in the representation of the block reflector.
[in]lddtINTEGER The leading dimension of the array T. LDDT >= K.
[in,out]dCREAL array on the GPU, dimension (LDDC,N) On entry, the m by n matrix C. On exit, C is overwritten by H*C, or H^H*C, or C*H, or C*H^H.
[in]lddcINTEGER The leading dimension of the array C. LDA >= max(1,M).
dwork(workspace) REAL array, dimension (LDWORK,K)
[in]ldworkINTEGER The leading dimension of the array WORK. If SIDE = MagmaLeft, LDWORK >= max(1,N); if SIDE = MagmaRight, LDWORK >= max(1,M);
dworkvt(workspace) REAL array, dimension (LDWORKT,K)
[in]ldworkvtINTEGER The leading dimension of the array WORKVT. LDWORKVT >= max(1,min(M,N));
[in]queuemagma_queue_t Queue to execute in.

Further Details

The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. All elements including 0's and 1's are stored, unlike LAPACK.

DIRECT = MagmaForward and         DIRECT = MagmaForward and
STOREV = MagmaColumnwise:         STOREV = MagmaRowwise:

         V = (  1  0  0 )                 V = (  1 v1 v1 v1 v1 )
             ( v1  1  0 )                     (  0  1 v2 v2 v2 )
             ( v1 v2  1 )                     (  0  0  1 v3 v3 )
             ( v1 v2 v3 )
             ( v1 v2 v3 )

DIRECT = MagmaBackward and        DIRECT = MagmaBackward and
STOREV = MagmaColumnwise:         STOREV = MagmaRowwise:

         V = ( v1 v2 v3 )                 V = ( v1 v1  1  0  0 )
             ( v1 v2 v3 )                     ( v2 v2 v2  1  0 )
             (  1 v2 v3 )                     ( v3 v3 v3 v3  1 )
             (  0  1 v3 )
             (  0  0  1 )
magma_int_t magma_slarfb_gpu_q ( magma_side_t  side,
magma_trans_t  trans,
magma_direct_t  direct,
magma_storev_t  storev,
magma_int_t  m,
magma_int_t  n,
magma_int_t  k,
magmaFloat_const_ptr  dV,
magma_int_t  lddv,
magmaFloat_const_ptr  dT,
magma_int_t  lddt,
magmaFloat_ptr  dC,
magma_int_t  lddc,
magmaFloat_ptr  dwork,
magma_int_t  ldwork,
magma_queue_t  queue 
)

SLARFB applies a real block reflector H or its transpose H^H to a REAL m by n matrix C, from the left.

Parameters
[in]sidemagma_side_t
  • = MagmaLeft: apply H or H^H from the Left
  • = MagmaRight: apply H or H^H from the Right
[in]transmagma_trans_t
  • = MagmaNoTrans: apply H (No transpose)
  • = MagmaTrans: apply H^H (Conjugate transpose)
[in]directmagma_direct_t Indicates how H is formed from a product of elementary reflectors
  • = MagmaForward: H = H(1) H(2) . . . H(k) (Forward)
  • = MagmaBackward: H = H(k) . . . H(2) H(1) (Backward)
[in]storevmagma_storev_t Indicates how the vectors which define the elementary reflectors are stored:
  • = MagmaColumnwise: Columnwise
  • = MagmaRowwise: Rowwise
[in]mINTEGER The number of rows of the matrix C.
[in]nINTEGER The number of columns of the matrix C.
[in]kINTEGER The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
[in]dVREAL array on the GPU, dimension (LDDV,K) if STOREV = MagmaColumnwise (LDDV,M) if STOREV = MagmaRowwise and SIDE = MagmaLeft (LDDV,N) if STOREV = MagmaRowwise and SIDE = MagmaRight The matrix V. See further details.
[in]lddvINTEGER The leading dimension of the array V. If STOREV = MagmaColumnwise and SIDE = MagmaLeft, LDDV >= max(1,M); if STOREV = MagmaColumnwise and SIDE = MagmaRight, LDDV >= max(1,N); if STOREV = MagmaRowwise, LDDV >= K.
[in]dTREAL array on the GPU, dimension (LDDT,K) The triangular k by k matrix T in the representation of the block reflector.
[in]lddtINTEGER The leading dimension of the array T. LDDT >= K.
[in,out]dCREAL array on the GPU, dimension (LDDC,N) On entry, the m by n matrix C. On exit, C is overwritten by H*C, or H^H*C, or C*H, or C*H^H.
[in]lddcINTEGER The leading dimension of the array C. LDA >= max(1,M).
dwork(workspace) REAL array, dimension (LDWORK,K)
[in]ldworkINTEGER The leading dimension of the array WORK. If SIDE = MagmaLeft, LDWORK >= max(1,N); if SIDE = MagmaRight, LDWORK >= max(1,M);
[in]queuemagma_queue_t Queue to execute in.

Further Details

The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. All elements including 0's and 1's are stored, unlike LAPACK.

DIRECT = MagmaForward and         DIRECT = MagmaForward and
STOREV = MagmaColumnwise:         STOREV = MagmaRowwise:

         V = (  1  0  0 )                 V = (  1 v1 v1 v1 v1 )
             ( v1  1  0 )                     (  0  1 v2 v2 v2 )
             ( v1 v2  1 )                     (  0  0  1 v3 v3 )
             ( v1 v2 v3 )
             ( v1 v2 v3 )

DIRECT = MagmaBackward and        DIRECT = MagmaBackward and
STOREV = MagmaColumnwise:         STOREV = MagmaRowwise:

         V = ( v1 v2 v3 )                 V = ( v1 v1  1  0  0 )
             ( v1 v2 v3 )                     ( v2 v2 v2  1  0 )
             (  1 v2 v3 )                     ( v3 v3 v3 v3  1 )
             (  0  1 v3 )
             (  0  0  1 )
void magma_slarfy ( magma_int_t  n,
float *  A,
magma_int_t  lda,
const float *  V,
const float *  TAU,
float *  work 
)

magma_slarfy applies an elementary reflector, or Householder matrix, H, to a n-by-n symmetric matrix C, from both the left and the right.

H is represented in the form

H = I - tau * v * v'

where tau is a scalar and v is a vector.

If tau is zero, then H is taken to be the unit matrix.

Parameters
[in]nThe number of rows and columns of the matrix C. n >= 0.
[in,out]AREAL array, dimension (lda, n) On entry, the Hermetian matrix A. On exit, A is overwritten by H * A * H'.
[in]ldaThe leading dimension of the array A. lda >= max(1,n).
[in]VThe vector V that contains the Householder reflectors.
[in]TAUThe value tau.
[out]workWorkspace.