FLA_QR_UT.h File Reference

(r)

Go to the source code of this file.

Functions
FLA_Error	FLA_QR_UT (FLA_Obj A, FLA_Obj T)
FLA_Error	FLA_QR_UT_internal (FLA_Obj A, FLA_Obj T, fla_qrut_t *cntl)
FLA_Error	FLA_QR_UT_copy_internal (FLA_Obj A, FLA_Obj T, FLA_Obj U, fla_qrut_t *cntl)
FLA_Error	FLA_QR_UT_create_T (FLA_Obj A, FLA_Obj *T)
FLA_Error	FLA_QR_UT_recover_tau (FLA_Obj T, FLA_Obj tau)
FLA_Error	FLA_QR_UT_solve (FLA_Obj A, FLA_Obj T, FLA_Obj B, FLA_Obj X)
FLA_Error	FLASH_QR_UT (FLA_Obj A, FLA_Obj TW)
FLA_Error	FLASH_QR_UT_create_hier_matrices (FLA_Obj A_flat, dim_t depth, dim_t *b_flash, FLA_Obj *A, FLA_Obj *TW)
FLA_Error	FLASH_QR_UT_solve (FLA_Obj A, FLA_Obj T, FLA_Obj B, FLA_Obj X)
FLA_Error	FLA_QR_UT_form_Q (FLA_Obj A, FLA_Obj T, FLA_Obj Q)
FLA_Error	FLA_QR_UT_form_Q_blk_var1 (FLA_Obj A, FLA_Obj T, FLA_Obj W)
FLA_Error	FLA_QR_UT_form_Q_opt_var1 (FLA_Obj A, FLA_Obj T)
FLA_Error	FLA_QR_UT_form_Q_ops_var1 (int m_A, int n_AT, float *buff_A, int rs_A, int cs_A, float *buff_T, int rs_T, int cs_T)
FLA_Error	FLA_QR_UT_form_Q_opd_var1 (int m_A, int n_AT, double *buff_A, int rs_A, int cs_A, double *buff_T, int rs_T, int cs_T)
FLA_Error	FLA_QR_UT_form_Q_opc_var1 (int m_A, int n_AT, scomplex *buff_A, int rs_A, int cs_A, scomplex *buff_T, int rs_T, int cs_T)
FLA_Error	FLA_QR_UT_form_Q_opz_var1 (int m_A, int n_AT, dcomplex *buff_A, int rs_A, int cs_A, dcomplex *buff_T, int rs_T, int cs_T)

Function Documentation

FLA_QR_UT()

FLA_Error FLA_QR_UT	(	FLA_Obj	A,
		FLA_Obj	T
	)

{
  FLA_Error r_val;
 
  // Check parameters.
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_QR_UT_check( A, T );
 
  // Invoke FLA_QR_UT_internal() with the standard control tree.
  //r_val = FLA_QR_UT_internal( A, T, fla_qrut_cntl2 );
  r_val = FLA_QR_UT_internal( A, T, fla_qrut_cntl_leaf );
 
  return r_val;
}

FLA_QR_UT_copy_internal()

FLA_Error FLA_QR_UT_copy_internal	(	FLA_Obj	A,
		FLA_Obj	T,
		FLA_Obj	U,
		fla_qrut_t *	cntl
	)

{
    FLA_Error r_val = FLA_SUCCESS;
    
    if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
        FLA_QR_UT_copy_internal_check( A, T, U, cntl );
 
    if ( FLASH_Queue_get_enabled() )
    {
        // Enqueue task.
        ENQUEUE_FLASH_QR_UT_copy( *FLASH_OBJ_PTR_AT( A ),
                                  *FLASH_OBJ_PTR_AT( T ),
                                  *FLASH_OBJ_PTR_AT( U ),
                                  NULL );
    }
    else
    {
        // Execute task immediately.
        FLA_QR_UT_copy_task( *FLASH_OBJ_PTR_AT( A ),
                             *FLASH_OBJ_PTR_AT( T ),
                             *FLASH_OBJ_PTR_AT( U ),
                             NULL );
    }
 
    return r_val;
}

References FLA_Check_error_level(), FLA_QR_UT_copy_internal_check(), FLA_QR_UT_copy_task(), FLASH_Queue_get_enabled(), and i.

Referenced by FLA_QR_UT_inc_blk_var2().

FLA_QR_UT_create_T()

FLA_Error FLA_QR_UT_create_T	(	FLA_Obj	A,
		FLA_Obj *	T
	)

{
  FLA_Datatype datatype;
  dim_t        b_alg, k;
  dim_t        rs_T, cs_T;
 
  // Query the datatype of A.
  datatype = FLA_Obj_datatype( A );
 
  // Query the blocksize from the library.
  b_alg = FLA_Query_blocksize( datatype, FLA_DIMENSION_MIN );
 
  // Scale the blocksize by a pre-set global constant.
  b_alg = ( dim_t )( ( ( double ) b_alg ) * FLA_QR_INNER_TO_OUTER_B_RATIO );
 
  // Adjust the blocksize with respect to the min-dim of A.
  b_alg = min(b_alg, FLA_Obj_min_dim( A ));
 
  // Query the width of A.
  k = FLA_Obj_width( A );
 
  // Figure out whether T should be row-major or column-major.
  if ( FLA_Obj_row_stride( A ) == 1 )
  {
    rs_T = 1;
    cs_T = b_alg;
  }
  else // if ( FLA_Obj_col_stride( A ) == 1 )
  {
    rs_T = k;
    cs_T = 1;
  }
 
  // Create a b_alg x k matrix to hold the block Householder transforms that
  // will be accumulated within the QR factorization algorithm.
  FLA_Obj_create( datatype, b_alg, k, rs_T, cs_T, T );
 
  return FLA_SUCCESS;
}

References FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_min_dim(), FLA_Obj_row_stride(), FLA_Obj_width(), FLA_Query_blocksize(), and i.

Referenced by FLA_Random_unitary_matrix(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

FLA_QR_UT_form_Q()

FLA_Error FLA_QR_UT_form_Q	(	FLA_Obj	A,
		FLA_Obj	T,
		FLA_Obj	Q
	)

{
    FLA_Error r_val = FLA_SUCCESS;
    FLA_Obj   QTL, QTR,
              QBL, QBR;
    FLA_Obj   W;
    dim_t     b;
 
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
        FLA_QR_UT_form_Q_check( A, T, Q );
 
    if ( FLA_Obj_is_overlapped( A, Q ) == FALSE )
    {
        // If A and Q are different objects, Q is explicitly formed with A.
 
        // Set Q identify
        FLA_Set_to_identity( Q );
 
        // Q = H_{0} H_{1} ... H_{k-1}
        FLA_Apply_Q_UT_create_workspace_side( FLA_LEFT, T, Q, &W );
        r_val = FLA_Apply_Q_UT( FLA_LEFT, FLA_NO_TRANSPOSE,
                                FLA_FORWARD, FLA_COLUMNWISE,
                                A, T, W, Q );
        FLA_Obj_free( &W );
 
    }
    else
    {
        // If A and Q are the same objects, Q is formed in-place.
        // - even if A and Q has the same base, they may have different
        //   dimensions.
        // - width of T controls the loop in FLA_QR_UT_form_Q_blk_var1.
 
        // Zero out the upper triangle of Q.
        FLA_Setr( FLA_UPPER_TRIANGULAR, FLA_ZERO, Q );
 
        // Adjust T w.r.t A; W is a place holder.
        if ( FLA_Obj_width( T ) > FLA_Obj_width( A ) )
            FLA_Part_1x2( T,    &T,   &W,
                          FLA_Obj_width( A ),
                          FLA_LEFT );
 
        // Zero out the lower triangle of QBR
        if ( FLA_Obj_width( Q ) > FLA_Obj_width( T ) )
        {
            b = FLA_Obj_width( T );
            FLA_Part_2x2( Q, &QTL, &QTR,
                             &QBL, &QBR, b, b, FLA_TL );
            FLA_Setr( FLA_LOWER_TRIANGULAR, FLA_ZERO, QBR );
        }
 
        // Set the digaonal to one.
        FLA_Set_diag( FLA_ONE, Q );
 
        // Create workspace for applying the block Householder transforms.
        FLA_Apply_Q_UT_create_workspace_side( FLA_LEFT, T, Q, &W );
 
        // Overwrite Q, which currently contains Householder vectors in the
        // strictly lower triangle and identity in the upper triangle, with
        // the unitary matrix associated with those Householder transforms.
        r_val = FLA_QR_UT_form_Q_blk_var1( Q, T, W );
 
        // Free the temporary workspace.
        FLA_Obj_free( &W );
    }
    /*
      FLA_Apply_Q_UT_create_workspace( T, Q, &W );
      FLA_Set_to_identity( Q );
      FLA_Apply_Q_UT( FLA_LEFT, FLA_NO_TRANSPOSE, FLA_FORWARD, FLA_COLUMNWISE,
      A, T, W, Q );
      FLA_Obj_free( &W );
      FLA_Obj_show( "Q", Q, "%8.1e %8.1e ", "" );
    */
 
    return r_val;
}

References FLA_Apply_Q_UT(), FLA_Apply_Q_UT_create_workspace_side(), FLA_Check_error_level(), FLA_Obj_free(), FLA_Obj_is_overlapped(), FLA_Obj_width(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x2(), FLA_QR_UT_form_Q_blk_var1(), FLA_QR_UT_form_Q_check(), FLA_Set_diag(), FLA_Set_to_identity(), FLA_Setr(), FLA_ZERO, and i.

Referenced by FLA_Bidiag_UT_form_U_ext(), FLA_LQ_UT_form_Q(), FLA_Random_unitary_matrix(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), FLA_Svd_uv_unb_var2(), and FLA_Tridiag_UT_form_Q().

FLA_QR_UT_form_Q_blk_var1()

FLA_Error FLA_QR_UT_form_Q_blk_var1	(	FLA_Obj	A,
		FLA_Obj	T,
		FLA_Obj	W
	)

{
    FLA_Obj ATL,   ATR,      A00, A01, A02,
            ABL,   ABR,      A10, A11, A12,
            A20, A21, A22;
 
    FLA_Obj TL,    TR,       T0,  T1,  T2;
 
    FLA_Obj T1T,
            T2B;
 
    FLA_Obj WTL,  WTR,
            WBL,  WBR;
 
    FLA_Obj AB1,   AB2;
 
    dim_t   b, b_alg;
    dim_t   m_BR, n_BR;
 
    b_alg = FLA_Obj_length( T );
 
 
    // If A is wider than T, then we need to position ourseves carefully
    // within the matrix for the initial partitioning.
    if ( FLA_Obj_width( A ) > FLA_Obj_width( T ) )
    {
        m_BR = FLA_Obj_length( A ) - FLA_Obj_width( T );
        n_BR = FLA_Obj_width( A ) - FLA_Obj_width( T );
    }
    else
    {
        m_BR = FLA_Obj_length( A ) - FLA_Obj_width( A );
        n_BR = 0;
    }
 
    FLA_Part_2x2( A,    &ATL, &ATR,
                        &ABL, &ABR,     m_BR, n_BR, FLA_BR );
 
    FLA_Part_1x2( T,    &TL,  &TR,      0, FLA_RIGHT );
 
    while ( /* FLA_Obj_min_dim( ATL ) > 0 && */ FLA_Obj_width( TL ) > 0 )
    {
        b = min( b_alg, FLA_Obj_min_dim( ATL ) );
 
        // Since T was filled from left to right, and since we need to access them
        // in reverse order, we need to handle the case where the last block is
        // smaller than the other b x b blocks.
        if ( FLA_Obj_width( TR ) == 0 && FLA_Obj_width( T ) % b_alg > 0 )
            b = FLA_Obj_width( T ) % b_alg;
 
        FLA_Repart_2x2_to_3x3( ATL, /**/ ATR,       &A00, &A01, /**/ &A02,
                                                    &A10, &A11, /**/ &A12,
                               /* ************* */   /* ******************** */
                               ABL, /**/ ABR,       &A20, &A21, /**/ &A22,
                               b, b, FLA_TL );
 
        FLA_Repart_1x2_to_1x3( TL,  /**/ TR,        &T0, &T1, /**/ &T2,
                               b, FLA_LEFT );
 
        /*------------------------------------------------------------*/
 
        FLA_Part_2x1( T1,    &T1T,
                             &T2B,     b, FLA_TOP );
 
        FLA_Part_2x2( W,     &WTL, &WTR,
                             &WBL, &WBR,     b, FLA_Obj_width( A12 ), FLA_TL );
 
        // Use an unblocked algorithm for the first (or only) block.
        if ( FLA_Obj_length( ABR ) == 0 )
        {
            FLA_QR_UT_form_Q_opt_var1( A11, T1T );
        }
        else
        {
            FLA_Merge_2x1( A11,
                           A21,   &AB1 );
            FLA_Merge_2x1( A12,
                           A22,   &AB2 );
 
            // Apply the block Householder transforms to A12 and A22.
            FLA_Apply_Q_UT( FLA_LEFT, FLA_NO_TRANSPOSE, FLA_FORWARD, FLA_COLUMNWISE,
                            AB1, T1T, WTL, AB2 );
 
            // Apply H to the current block panel consisting of A11 and A21.
            FLA_QR_UT_form_Q_opt_var1( AB1, T1T );
        }
 
        /*------------------------------------------------------------*/
 
        FLA_Cont_with_3x3_to_2x2( &ATL, /**/ &ATR,       A00, /**/ A01, A02,
                                  /* ************** */  /* ****************** */
                                                         A10, /**/ A11, A12,
                                  &ABL, /**/ &ABR,       A20, /**/ A21, A22,
                                  FLA_BR );
 
        FLA_Cont_with_1x3_to_1x2( &TL,  /**/ &TR,        T0, /**/ T1, T2,
                                  FLA_RIGHT );
    }
 
    return FLA_SUCCESS;
}

References FLA_Apply_Q_UT(), FLA_Cont_with_1x3_to_1x2(), FLA_Cont_with_3x3_to_2x2(), FLA_Merge_2x1(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_width(), FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_QR_UT_form_Q_opt_var1(), FLA_Repart_1x2_to_1x3(), FLA_Repart_2x2_to_3x3(), and i.

Referenced by FLA_QR_UT_form_Q().

FLA_QR_UT_form_Q_opc_var1()

FLA_Error FLA_QR_UT_form_Q_opc_var1	(	int	m_A,
		int	n_AT,
		scomplex *	buff_A,
		int	rs_A,
		int	cs_A,
		scomplex *	buff_T,
		int	rs_T,
		int	cs_T
	)

{
    scomplex zero    = bl1_c0();
    scomplex one     = bl1_c1();
    int      min_m_n = min( m_A, n_A );
    int      i;
 
    for ( i = min_m_n - 1; i >= 0; --i )
    {
        //scomplex* a01      = buff_A + (i  )*cs_A + (0  )*rs_A;
        scomplex* alpha11  = buff_A + (i  )*cs_A + (i  )*rs_A;
        scomplex* a21      = buff_A + (i  )*cs_A + (i+1)*rs_A;
        scomplex* a12t     = buff_A + (i+1)*cs_A + (i  )*rs_A;
        scomplex* A22      = buff_A + (i+1)*cs_A + (i+1)*rs_A;
 
        scomplex* tau11    = buff_T + (i  )*cs_T + (i  )*rs_T;
 
        scomplex  minus_inv_tau11;
 
        //int       m_behind = i;
        int       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;
 
        FLA_Apply_H2_UT_l_opc_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a21,  rs_A,
                                    a12t, cs_A,
                                    A22,  rs_A, cs_A );
 
        minus_inv_tau11.real = -one.real / tau11->real;
        minus_inv_tau11.imag = zero.imag;
 
        alpha11->real = one.real + minus_inv_tau11.real;
        alpha11->imag = zero.imag;
 
        bl1_cscalv( BLIS1_NO_CONJUGATE,
                    m_ahead,
                    &minus_inv_tau11,
                    a21, rs_A );
 
        // Not necessary if upper triangle of A is initialized to identity.
        //bl1_csetv( m_behind,
        //           &zero,
        //           a01, rs_A );
    }
 
    return FLA_SUCCESS;
}

References bl1_c0(), bl1_c1(), bl1_cscalv(), BLIS1_NO_CONJUGATE, FLA_Apply_H2_UT_l_opc_var1(), and i.

Referenced by FLA_QR_UT_form_Q_opt_var1().

FLA_QR_UT_form_Q_opd_var1()

FLA_Error FLA_QR_UT_form_Q_opd_var1	(	int	m_A,
		int	n_AT,
		double *	buff_A,
		int	rs_A,
		int	cs_A,
		double *	buff_T,
		int	rs_T,
		int	cs_T
	)

{
    double   one     = bl1_d1();
    int      min_m_n = min( m_A, n_A );
    int      i;
 
    for ( i = min_m_n - 1; i >= 0; --i )
    {
        //double*   a01      = buff_A + (i  )*cs_A + (0  )*rs_A;
        double*   alpha11  = buff_A + (i  )*cs_A + (i  )*rs_A;
        double*   a21      = buff_A + (i  )*cs_A + (i+1)*rs_A;
        double*   a12t     = buff_A + (i+1)*cs_A + (i  )*rs_A;
        double*   A22      = buff_A + (i+1)*cs_A + (i+1)*rs_A;
 
        double*   tau11    = buff_T + (i  )*cs_T + (i  )*rs_T;
 
        double    minus_inv_tau11;
 
        //int       m_behind = i;
        int       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;
 
        FLA_Apply_H2_UT_l_opd_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a21,  rs_A,
                                    a12t, cs_A,
                                    A22,  rs_A, cs_A );
 
        minus_inv_tau11 = -one / *tau11;
 
        *alpha11 = one + minus_inv_tau11;
 
        bl1_dscalv( BLIS1_NO_CONJUGATE,
                    m_ahead,
                    &minus_inv_tau11,
                    a21, rs_A );
 
        // Not necessary if upper triangle of A is initialized to identity.
        //bl1_dsetv( m_behind,
        //           &zero,
        //           a01, rs_A );
    }
 
    return FLA_SUCCESS;
}

References bl1_d1(), bl1_dscalv(), BLIS1_NO_CONJUGATE, FLA_Apply_H2_UT_l_opd_var1(), and i.

Referenced by FLA_QR_UT_form_Q_opt_var1().

FLA_QR_UT_form_Q_ops_var1()

FLA_Error FLA_QR_UT_form_Q_ops_var1	(	int	m_A,
		int	n_AT,
		float *	buff_A,
		int	rs_A,
		int	cs_A,
		float *	buff_T,
		int	rs_T,
		int	cs_T
	)

{
    float    one     = bl1_d1();
    int      min_m_n = min( m_A, n_A );
    int      i;
 
    for ( i = min_m_n - 1; i >= 0; --i )
    {
        //float*    a01      = buff_A + (i  )*cs_A + (0  )*rs_A;
        float*    alpha11  = buff_A + (i  )*cs_A + (i  )*rs_A;
        float*    a21      = buff_A + (i  )*cs_A + (i+1)*rs_A;
        float*    a12t     = buff_A + (i+1)*cs_A + (i  )*rs_A;
        float*    A22      = buff_A + (i+1)*cs_A + (i+1)*rs_A;
 
        float*    tau11    = buff_T + (i  )*cs_T + (i  )*rs_T;
 
        float     minus_inv_tau11;
 
        //int       m_behind = i;
        int       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;
 
        FLA_Apply_H2_UT_l_ops_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a21,  rs_A,
                                    a12t, cs_A,
                                    A22,  rs_A, cs_A );
 
        minus_inv_tau11 = -one / *tau11;
 
        *alpha11 = one + minus_inv_tau11;
 
        bl1_sscalv( BLIS1_NO_CONJUGATE,
                    m_ahead,
                    &minus_inv_tau11,
                    a21, rs_A );
 
        // Not necessary if upper triangle of A is initialized to identity.
        //bl1_ssetv( m_behind,
        //           &zero,
        //           a01, rs_A );
    }
 
    return FLA_SUCCESS;
}

References bl1_d1(), bl1_sscalv(), BLIS1_NO_CONJUGATE, FLA_Apply_H2_UT_l_ops_var1(), and i.

Referenced by FLA_QR_UT_form_Q_opt_var1().

FLA_QR_UT_form_Q_opt_var1()

FLA_Error FLA_QR_UT_form_Q_opt_var1	(	FLA_Obj	A,
		FLA_Obj	T
	)

{
    FLA_Datatype datatype;
    int          m_A, n_A;
    int          rs_A, cs_A;
    int          rs_T, cs_T;
 
    datatype = FLA_Obj_datatype( A );
 
    m_A      = FLA_Obj_length( A );
    n_A      = FLA_Obj_width( A );
    rs_A     = FLA_Obj_row_stride( A );
    cs_A     = FLA_Obj_col_stride( A );
 
    rs_T     = FLA_Obj_row_stride( T );
    cs_T     = FLA_Obj_col_stride( T );
 
    switch ( datatype )
    {
    case FLA_FLOAT:
    {
        float*    buff_A = ( float* ) FLA_FLOAT_PTR( A );
        float*    buff_T = ( float* ) FLA_FLOAT_PTR( T );
 
        FLA_QR_UT_form_Q_ops_var1( m_A,
                                   n_A,
                                   buff_A, rs_A, cs_A,
                                   buff_T, rs_T, cs_T );
 
        break;
    }
 
    case FLA_DOUBLE:
    {
        double*   buff_A = ( double* ) FLA_DOUBLE_PTR( A );
        double*   buff_T = ( double* ) FLA_DOUBLE_PTR( T );
 
        FLA_QR_UT_form_Q_opd_var1( m_A,
                                   n_A,
                                   buff_A, rs_A, cs_A,
                                   buff_T, rs_T, cs_T );
 
        break;
    }
 
    case FLA_COMPLEX:
    {
        scomplex* buff_A = ( scomplex* ) FLA_COMPLEX_PTR( A );
        scomplex* buff_T = ( scomplex* ) FLA_COMPLEX_PTR( T );
 
        FLA_QR_UT_form_Q_opc_var1( m_A,
                                   n_A,
                                   buff_A, rs_A, cs_A,
                                   buff_T, rs_T, cs_T );
 
        break;
    }
 
    case FLA_DOUBLE_COMPLEX:
    {
        dcomplex* buff_A = ( dcomplex* ) FLA_DOUBLE_COMPLEX_PTR( A );
        dcomplex* buff_T = ( dcomplex* ) FLA_DOUBLE_COMPLEX_PTR( T );
 
        FLA_QR_UT_form_Q_opz_var1( m_A,
                                   n_A,
                                   buff_A, rs_A, cs_A,
                                   buff_T, rs_T, cs_T );
 
        break;
    }
    }
 
    return FLA_SUCCESS;
}

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_width(), FLA_QR_UT_form_Q_opc_var1(), FLA_QR_UT_form_Q_opd_var1(), FLA_QR_UT_form_Q_ops_var1(), FLA_QR_UT_form_Q_opz_var1(), and i.

Referenced by FLA_QR_UT_form_Q_blk_var1().

FLA_QR_UT_form_Q_opz_var1()

FLA_Error FLA_QR_UT_form_Q_opz_var1	(	int	m_A,
		int	n_AT,
		dcomplex *	buff_A,
		int	rs_A,
		int	cs_A,
		dcomplex *	buff_T,
		int	rs_T,
		int	cs_T
	)

{
    dcomplex zero    = bl1_z0();
    dcomplex one     = bl1_z1();
    int      min_m_n = min( m_A, n_A );
    int      i;
 
    for ( i = min_m_n - 1; i >= 0; --i )
    {
        //dcomplex* a01      = buff_A + (i  )*cs_A + (0  )*rs_A;
        dcomplex* alpha11  = buff_A + (i  )*cs_A + (i  )*rs_A;
        dcomplex* a21      = buff_A + (i  )*cs_A + (i+1)*rs_A;
        dcomplex* a12t     = buff_A + (i+1)*cs_A + (i  )*rs_A;
        dcomplex* A22      = buff_A + (i+1)*cs_A + (i+1)*rs_A;
 
        dcomplex* tau11    = buff_T + (i  )*cs_T + (i  )*rs_T;
 
        dcomplex  minus_inv_tau11;
 
        //int       m_behind = i;
        int       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;
 
        FLA_Apply_H2_UT_l_opz_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a21,  rs_A,
                                    a12t, cs_A,
                                    A22,  rs_A, cs_A );
 
        minus_inv_tau11.real = -one.real / tau11->real;
        minus_inv_tau11.imag = zero.imag;
 
        alpha11->real = one.real + minus_inv_tau11.real;
        alpha11->imag = zero.imag;
 
        bl1_zscalv( BLIS1_NO_CONJUGATE,
                    m_ahead,
                    &minus_inv_tau11,
                    a21, rs_A );
 
        // Not necessary if upper triangle of A is initialized to identity.
        //bl1_zsetv( m_behind,
        //           &zero,
        //           a01, rs_A );
    }
 
    return FLA_SUCCESS;
}

References bl1_z0(), bl1_z1(), bl1_zscalv(), BLIS1_NO_CONJUGATE, FLA_Apply_H2_UT_l_opz_var1(), and i.

Referenced by FLA_QR_UT_form_Q_opt_var1().

FLA_QR_UT_internal()

FLA_Error FLA_QR_UT_internal	(	FLA_Obj	A,
		FLA_Obj	T,
		fla_qrut_t *	cntl
	)

{
    FLA_Error r_val = FLA_SUCCESS;
    
    if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
        FLA_QR_UT_internal_check( A, T, cntl );
 
    if      ( FLA_Cntl_matrix_type( cntl ) == FLA_HIER &&
              FLA_Cntl_variant( cntl ) == FLA_SUBPROBLEM )
    {
        if ( FLASH_Queue_get_enabled( ) )
        {
            // Enqueue
            ENQUEUE_FLASH_QR_UT_macro( A, *FLASH_OBJ_PTR_AT( T ), cntl );
        }
        else
        {
            // Execute
            r_val = FLA_QR_UT_macro_task( A, *FLASH_OBJ_PTR_AT( T ), cntl );
        }
    }
    else
    {
        if      ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT1 )
        {
            r_val = FLA_QR_UT_unb_var1( A, T );
        }
        else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT1 )
        {
            r_val = FLA_QR_UT_opt_var1( A, T );
        }
        else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT1 )
        {
            r_val = FLA_QR_UT_blk_var1( A, T, cntl );
        }
        else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT2 )
        {
            r_val = FLA_QR_UT_unb_var2( A, T );
        }
        else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT2 )
        {
            r_val = FLA_QR_UT_opt_var2( A, T );
        }
        else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT2 )
        {
            r_val = FLA_QR_UT_blk_var2( A, T, cntl );
        }
        else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT3 )
        {
            r_val = FLA_QR_UT_blk_var3( A, T, cntl );
        }
        else
        {
            FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
        }
    }
 
    return r_val;
}

References FLA_Check_error_level(), FLA_QR_UT_blk_var1(), FLA_QR_UT_blk_var2(), FLA_QR_UT_blk_var3(), FLA_QR_UT_internal_check(), FLA_QR_UT_macro_task(), FLA_QR_UT_opt_var1(), FLA_QR_UT_opt_var2(), FLA_QR_UT_unb_var1(), FLA_QR_UT_unb_var2(), FLASH_Queue_get_enabled(), and i.

Referenced by FLA_QR_UT(), FLA_QR_UT_blk_var1(), FLA_QR_UT_blk_var2(), FLA_QR_UT_blk_var3(), FLA_QR_UT_copy_task(), FLA_QR_UT_inc_blk_var1(), FLA_QR_UT_macro_task(), FLA_QR_UT_task(), and FLASH_QR_UT().

FLA_QR_UT_recover_tau()

FLA_Error FLA_QR_UT_recover_tau	(	FLA_Obj	T,
		FLA_Obj	tau
	)

{
  FLA_Obj TL,    TR,       T0,  T1,  T2;
 
  FLA_Obj tT,              t0,
          tB,              t1,
                           t2;
 
  dim_t b_alg, b;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_QR_UT_recover_tau_check( T, t );
 
  b_alg = FLA_Obj_length( T );
 
  FLA_Part_1x2( T,    &TL,  &TR,      0, FLA_LEFT );
 
  FLA_Part_2x1( t,    &tT, 
                      &tB,            0, FLA_TOP );
 
  // T matrix may include workspace; thus, T should not be placed as a loop guard.
  while ( FLA_Obj_length( tB ) > 0 ) {
 
    // The blocksize should be determined that the T matrix is square.
    b = min( FLA_Obj_length( tB ), b_alg );
 
    FLA_Repart_1x2_to_1x3( TL,  /**/ TR,        &T0, /**/ &T1, &T2,
                           b, FLA_RIGHT );
 
    FLA_Repart_2x1_to_3x1( tT,                &t0, 
                        /* ** */            /* ** */
                                              &t1, 
                           tB,                &t2,        b, FLA_BOTTOM );
 
    /*------------------------------------------------------------*/
 
    FLA_QR_UT_recover_tau_submatrix( T1, t1 );
 
    /*------------------------------------------------------------*/
 
    FLA_Cont_with_1x3_to_1x2( &TL,  /**/ &TR,        T0, T1, /**/ T2,
                              FLA_LEFT );
 
    FLA_Cont_with_3x1_to_2x1( &tT,                t0, 
                                                  t1, 
                            /* ** */           /* ** */
                              &tB,                t2,     FLA_TOP );
  }
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Cont_with_1x3_to_1x2(), FLA_Cont_with_3x1_to_2x1(), FLA_Obj_length(), FLA_Part_1x2(), FLA_Part_2x1(), FLA_QR_UT_recover_tau_check(), FLA_QR_UT_recover_tau_submatrix(), FLA_Repart_1x2_to_1x3(), FLA_Repart_2x1_to_3x1(), and i.

Referenced by FLA_LQ_UT_recover_tau().

FLA_QR_UT_solve()

FLA_Error FLA_QR_UT_solve	(	FLA_Obj	A,
		FLA_Obj	T,
		FLA_Obj	B,
		FLA_Obj	X
	)

{
  FLA_Obj W, Y;
  FLA_Obj AT, AB;
  FLA_Obj YT, YB;
 
  // Check parameters.
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_QR_UT_solve_check( A, T, B, X );
 
  FLA_Apply_Q_UT_create_workspace( T, B, &W );
 
  FLA_Obj_create_copy_of( FLA_NO_TRANSPOSE, B, &Y );
 
  FLA_Apply_Q_UT( FLA_LEFT, FLA_CONJ_TRANSPOSE, FLA_FORWARD, FLA_COLUMNWISE,
                  A, T, W, Y );
 
  FLA_Part_2x1( A,   &AT,
                     &AB,    FLA_Obj_width( A ), FLA_TOP );
  FLA_Part_2x1( Y,   &YT,
                     &YB,    FLA_Obj_width( A ), FLA_TOP );
 
  FLA_Trsm_external( FLA_LEFT, FLA_UPPER_TRIANGULAR, FLA_NO_TRANSPOSE,
                     FLA_NONUNIT_DIAG, FLA_ONE, AT, YT );
 
  FLA_Copy_external( YT, X );
 
  FLA_Obj_free( &Y );
  FLA_Obj_free( &W );
 
  return FLA_SUCCESS;
}

References FLA_Apply_Q_UT(), FLA_Apply_Q_UT_create_workspace(), FLA_Check_error_level(), FLA_Copy_external(), FLA_Obj_create_copy_of(), FLA_Obj_free(), FLA_Obj_width(), FLA_ONE, FLA_Part_2x1(), FLA_QR_UT_solve_check(), FLA_Trsm_external(), and i.

FLASH_QR_UT()

FLA_Error FLASH_QR_UT	(	FLA_Obj	A,
		FLA_Obj	TW
	)

{
  FLA_Error r_val;
  dim_t     b_alg, b_flash;
 
  // Check parameters.
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_QR_UT_check( A, TW );
 
  // *** The current hierarchical QR_UT algorithm assumes that the matrix
  // has a hierarchical depth of 1. We check for that here, because we
  //  anticipate that we'll use a more general algorithm in the future, and
  // we don't want to forget to remove the constraint. ***
  if ( FLASH_Obj_depth( A ) != 1 )
  {
    FLA_Print_message( "FLASH_QR_UT() currently only supports matrices of depth 1",
                       __FILE__, __LINE__ );
    FLA_Abort();
  }
 
  // Inspect the length of TTL to get the blocksize used by the QR
  // factorization, which will be our inner blocksize for Apply_Q_UT.
  b_alg   = FLASH_Obj_scalar_length_tl( TW );
  b_flash = FLASH_Obj_scalar_width_tl( TW );
 
  // The traditional (non-incremental) QR_UT algorithm-by-blocks requires
  // that the algorithmic blocksize be equal to the storage blocksize.
  if ( b_alg != b_flash )
  {
    FLA_Print_message( "FLASH_QR_UT() requires that b_alg == b_store",
                       __FILE__, __LINE__ );
    FLA_Abort();
  }
 
  // The traditional (non-incremental) QR_UT algorithm-by-blocks requires
  // that min_dim(A) % b_flash == 0.
  if ( FLASH_Obj_scalar_min_dim( A ) % b_flash != 0 )
  {
    FLA_Print_message( "FLASH_QR_UT() requires that min_dim( A ) %% b_store == 0",
                       __FILE__, __LINE__ );
    FLA_Abort();
  }
 
  // Begin a parallel region.
  FLASH_Queue_begin();
 
  // Invoke FLA_QR_UT_internal() with hierarchical control tree.
  r_val = FLA_QR_UT_internal( A, TW, flash_qrut_cntl );
 
  // End the parallel region.
  FLASH_Queue_end();
 
  return r_val;
}

FLASH_QR_UT_create_hier_matrices()

FLA_Error FLASH_QR_UT_create_hier_matrices	(	FLA_Obj	A_flat,
		dim_t	depth,
		dim_t *	b_flash,
		FLA_Obj *	A,
		FLA_Obj *	TW
	)

{
    FLA_Datatype datatype;
    dim_t        m, n;
    dim_t        min_m_n;
    
    // *** The current QR_UT algorithm implemented assumes that
    // the matrix has a hierarchical depth of 1. We check for that here
    // because we anticipate that we'll use a more general algorithm in the
    // future, and we don't want to forget to remove the constraint. ***
    if ( depth != 1 )
    {
       FLA_Print_message( "FLASH_QR_UT() currently only supports matrices of depth 1",
                          __FILE__, __LINE__ );
       FLA_Abort();
    }
 
    // Create hierarchical copy of matrix A_flat.
    FLASH_Obj_create_hier_copy_of_flat( A_flat, depth, b_flash, A );
 
    // Query the datatype of matrix A_flat.
    datatype = FLA_Obj_datatype( A_flat );
    
    // Query the minimum dimension of A_flat.
    min_m_n = FLA_Obj_min_dim( A_flat );
 
    // Set the m and n dimensions of TW to be min_m_n.
    m = min_m_n;
    n = min_m_n;
 
    // Create hierarchical matrices T and W.
    FLASH_Obj_create_ext( datatype, m, n, 
                          depth, b_flash, b_flash, 
                          TW );
       
    return FLA_SUCCESS;
}

References FLA_Abort(), FLA_Obj_datatype(), FLA_Obj_min_dim(), FLA_Print_message(), FLASH_Obj_create_ext(), FLASH_Obj_create_hier_copy_of_flat(), and i.

FLASH_QR_UT_solve()

FLA_Error FLASH_QR_UT_solve	(	FLA_Obj	A,
		FLA_Obj	T,
		FLA_Obj	B,
		FLA_Obj	X
	)

{
  FLA_Obj W, Y;
  FLA_Obj AT, AB;
  FLA_Obj YT, YB;
 
  // Check parameters.
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_QR_UT_solve_check( A, TW, B, X );
 
  FLASH_Apply_Q_UT_create_workspace( TW, B, &W );
 
  FLASH_Obj_create_copy_of( FLA_NO_TRANSPOSE, B, &Y );
 
  FLASH_Apply_Q_UT( FLA_LEFT, FLA_CONJ_TRANSPOSE, FLA_FORWARD, FLA_COLUMNWISE,
                    A, TW, W, Y );
 
  FLA_Part_2x1( A,   &AT,
                     &AB,    FLA_Obj_width( A ), FLA_TOP );
  FLA_Part_2x1( Y,   &YT,
                     &YB,    FLA_Obj_width( A ), FLA_TOP );
 
  FLASH_Trsm( FLA_LEFT, FLA_UPPER_TRIANGULAR, FLA_NO_TRANSPOSE, FLA_NONUNIT_DIAG,
              FLA_ONE, AT, YT );
 
  FLASH_Copy( YT, X );
 
  FLASH_Obj_free( &Y );
  FLASH_Obj_free( &W );
 
  return FLA_SUCCESS;
}