MAGMA 2.9.0
Matrix Algebra for GPU and Multicore Architectures
Loading...
Searching...
No Matches
Functions
larfb: Apply block of Householder reflectors (Level 3)
Batched LA » MAGMA BLAS and Auxiliary » Householder reflectors

Functions

magma_int_t magma_clarfb_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, magmaFloatComplex_const_ptr dV_array[], magma_int_t lddv, magmaFloatComplex_const_ptr dT_array[], magma_int_t lddt, magmaFloatComplex_ptr dC_array[], magma_int_t lddc, magmaFloatComplex_ptr dwork_array[], magma_int_t ldwork, magmaFloatComplex_ptr dworkvt_array[], magma_int_t ldworkvt, magma_int_t batchCount, magma_queue_t queue)
 CLARFB applies a complex block reflector H or its transpose H^H to a COMPLEX m by n matrix C, from the left.
 
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)
 DLARFB applies a real block reflector H or its transpose H^H to a DOUBLE PRECISION m by n matrix C, from the left.
 
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.
 
magma_int_t magma_zlarfb_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, magmaDoubleComplex_const_ptr dV_array[], magma_int_t lddv, magmaDoubleComplex_const_ptr dT_array[], magma_int_t lddt, magmaDoubleComplex_ptr dC_array[], magma_int_t lddc, magmaDoubleComplex_ptr dwork_array[], magma_int_t ldwork, magmaDoubleComplex_ptr dworkvt_array[], magma_int_t ldworkvt, magma_int_t batchCount, magma_queue_t queue)
 ZLARFB applies a complex block reflector H or its transpose H^H to a COMPLEX_16 m by n matrix C, from the left.
 

Detailed Description

Function Documentation

◆ magma_clarfb_gemm_batched()

magma_int_t magma_clarfb_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,
magmaFloatComplex_const_ptr dV_array[],
magma_int_t lddv,
magmaFloatComplex_const_ptr dT_array[],
magma_int_t lddt,
magmaFloatComplex_ptr dC_array[],
magma_int_t lddc,
magmaFloatComplex_ptr dwork_array[],
magma_int_t ldwork,
magmaFloatComplex_ptr dworkvt_array[],
magma_int_t ldworkvt,
magma_int_t batchCount,
magma_queue_t queue )

CLARFB applies a complex block reflector H or its transpose H^H to a COMPLEX 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)
  • = Magma_ConjTrans: 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_arrayCOMPLEX 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_arrayCOMPLEX 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_arrayCOMPLEX 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. LDDC >= max(1,M).
dwork_array(workspace) COMPLEX 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) COMPLEX 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_dlarfb_gemm_batched()

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 )

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. LDDC >= 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));
[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_slarfb_gemm_batched()

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. LDDC >= 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_zlarfb_gemm_batched()

magma_int_t magma_zlarfb_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,
magmaDoubleComplex_const_ptr dV_array[],
magma_int_t lddv,
magmaDoubleComplex_const_ptr dT_array[],
magma_int_t lddt,
magmaDoubleComplex_ptr dC_array[],
magma_int_t lddc,
magmaDoubleComplex_ptr dwork_array[],
magma_int_t ldwork,
magmaDoubleComplex_ptr dworkvt_array[],
magma_int_t ldworkvt,
magma_int_t batchCount,
magma_queue_t queue )

ZLARFB applies a complex block reflector H or its transpose H^H to a COMPLEX_16 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)
  • = Magma_ConjTrans: 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_arrayCOMPLEX_16 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_arrayCOMPLEX_16 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_arrayCOMPLEX_16 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. LDDC >= max(1,M).
dwork_array(workspace) COMPLEX_16 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) COMPLEX_16 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 )