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

Functions

void magma_dlarfy (magma_int_t n, double *A, magma_int_t lda, const double *V, const double *TAU, double *work)
 magma_dlarfy 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_dlarfb_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, magmaDouble_const_ptr dV_array[], magma_int_t lddv, magmaDouble_const_ptr dT_array[], magma_int_t lddt, magmaDouble_ptr dC_array[], magma_int_t lddc, magmaDouble_ptr dwork_array[], magma_int_t ldwork, magmaDouble_ptr dworkvt_array[], magma_int_t ldworkvt, magma_int_t batchCount, magma_queue_t queue, cublasHandle_t myhandle)
 DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE_PRECISION m by n matrix C, from the left. More...
 
magma_int_t magma_dlarfb_gpu (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, magmaDouble_const_ptr dV, magma_int_t lddv, magmaDouble_const_ptr dT, magma_int_t lddt, magmaDouble_ptr dC, magma_int_t lddc, magmaDouble_ptr dwork, magma_int_t ldwork)
 DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE_PRECISION m by n matrix C, from the left. More...
 
magma_int_t magma_dlarfb_gpu_gemm (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, magmaDouble_const_ptr dV, magma_int_t lddv, magmaDouble_const_ptr dT, magma_int_t lddt, magmaDouble_ptr dC, magma_int_t lddc, magmaDouble_ptr dwork, magma_int_t ldwork, magmaDouble_ptr dworkvt, magma_int_t ldworkvt)
 DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE_PRECISION m by n matrix C, from the left. More...
 

Detailed Description

Function Documentation

magma_int_t magma_dlarfb_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,
magmaDouble_const_ptr  dV_array[],
magma_int_t  lddv,
magmaDouble_const_ptr  dT_array[],
magma_int_t  lddt,
magmaDouble_ptr  dC_array[],
magma_int_t  lddc,
magmaDouble_ptr  dwork_array[],
magma_int_t  ldwork,
magmaDouble_ptr  dworkvt_array[],
magma_int_t  ldworkvt,
magma_int_t  batchCount,
magma_queue_t  queue,
cublasHandle_t  myhandle 
)

DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE_PRECISION 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_arrayDOUBLE_PRECISION 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_arrayDOUBLE_PRECISION 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_arrayDOUBLE_PRECISION 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) DOUBLE_PRECISION 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) DOUBLE_PRECISION array, dimension (LDWORKT,K)
[in]ldworkvtINTEGER The leading dimension of the array WORKVT. LDWORKVT >= max(1,min(M,N));

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_dlarfb_gpu ( 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,
magmaDouble_const_ptr  dV,
magma_int_t  lddv,
magmaDouble_const_ptr  dT,
magma_int_t  lddt,
magmaDouble_ptr  dC,
magma_int_t  lddc,
magmaDouble_ptr  dwork,
magma_int_t  ldwork 
)

DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE_PRECISION 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]dVDOUBLE_PRECISION 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]dTDOUBLE_PRECISION 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]dCDOUBLE_PRECISION 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) DOUBLE_PRECISION 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);

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_dlarfb_gpu_gemm ( 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,
magmaDouble_const_ptr  dV,
magma_int_t  lddv,
magmaDouble_const_ptr  dT,
magma_int_t  lddt,
magmaDouble_ptr  dC,
magma_int_t  lddc,
magmaDouble_ptr  dwork,
magma_int_t  ldwork,
magmaDouble_ptr  dworkvt,
magma_int_t  ldworkvt 
)

DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE_PRECISION 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]dVDOUBLE_PRECISION 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]dTDOUBLE_PRECISION 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]dCDOUBLE_PRECISION 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) DOUBLE_PRECISION 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) DOUBLE_PRECISION array, dimension (LDWORKT,K)
[in]ldworkvtINTEGER The leading dimension of the array WORKVT. LDWORKVT >= max(1,min(M,N));

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_dlarfy ( magma_int_t  n,
double *  A,
magma_int_t  lda,
const double *  V,
const double *  TAU,
double *  work 
)

magma_dlarfy 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]ADOUBLE PRECISION 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.