FLA_LQ_UT_form_Q.c File Reference

(r)

Functions
FLA_Error	FLA_LQ_UT_form_Q (FLA_Obj A, FLA_Obj T, FLA_Obj Q)
FLA_Error	FLA_LQ_UT_form_Q_blk_var1 (FLA_Obj A, FLA_Obj T, FLA_Obj W)
FLA_Error	FLA_LQ_UT_form_Q_opt_var1 (FLA_Obj A, FLA_Obj T)
FLA_Error	FLA_LQ_UT_form_Q_ops_var1 (int m_A, int n_A, float *buff_A, int rs_A, int cs_A, float *buff_T, int rs_T, int cs_T)
FLA_Error	FLA_LQ_UT_form_Q_opd_var1 (int m_A, int n_A, double *buff_A, int rs_A, int cs_A, double *buff_T, int rs_T, int cs_T)
FLA_Error	FLA_LQ_UT_form_Q_opc_var1 (int m_A, int n_A, scomplex *buff_A, int rs_A, int cs_A, scomplex *buff_T, int rs_T, int cs_T)
FLA_Error	FLA_LQ_UT_form_Q_opz_var1 (int m_A, int n_A, dcomplex *buff_A, int rs_A, int cs_A, dcomplex *buff_T, int rs_T, int cs_T)

---

Function Documentation

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

References FLA_Apply_Q_UT_create_workspace(), FLA_Check_error_level(), FLA_Copyr(), FLA_LQ_UT_form_Q_blk_var1(), FLA_LQ_UT_form_Q_check(), FLA_Merge_1x2(), FLA_Obj_free(), FLA_Obj_is(), FLA_Obj_length(), FLA_ONE, FLA_Part_2x2(), FLA_Set_diag(), FLA_Setr(), and FLA_ZERO.

{
    FLA_Error r_val = FLA_SUCCESS;
    FLA_Obj   QTL, QTR,
              QBL, QBR;
    FLA_Obj   QT;
    FLA_Obj   W;
    dim_t     m_A;

    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
        FLA_LQ_UT_form_Q_check( A, T, Q );

    // Zero out the lower triangle of Q.
    FLA_Setr( FLA_LOWER_TRIANGULAR, FLA_ZERO, Q );

    // Set the digaonal to one.
    FLA_Set_diag( FLA_ONE, Q );

    // If A and Q are different objects, copy the Householder vectors
    // from A to QT, and zero out the upper triangle of QBR. If they
    // are the same object, we don't need to do the copy, and don't
    // need to zero anything out since the user should only have A and
    // Q be the same object if A is square, since Q needs to be square
    // (specifically, dim(Q) needs to equal n(A)).
    if ( FLA_Obj_is( A, Q ) == FALSE )
    {
        m_A = FLA_Obj_length( A );
        FLA_Part_2x2( Q,   &QTL, &QTR,
                           &QBL, &QBR,   m_A, m_A, FLA_TL );
        FLA_Merge_1x2( QTL, QTR,  &QT );

        // Copy the Householder vectors in A to QT.
        FLA_Copyr( FLA_UPPER_TRIANGULAR, A, QT );

        // Zero out the lower triangle of QBR.
        FLA_Setr( FLA_UPPER_TRIANGULAR, FLA_ZERO, QBR );
    }

    // Create workspace for applying the block Householder transforms.
    FLA_Apply_Q_UT_create_workspace( 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_LQ_UT_form_Q_blk_var1( Q, T, W );
    
    // Free the temporary workspace.
    FLA_Obj_free( &W );

    return r_val;
}

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

References FLA_Apply_Q_UT(), FLA_Cont_with_1x3_to_1x2(), FLA_Cont_with_3x3_to_2x2(), FLA_LQ_UT_form_Q_opt_var1(), FLA_Merge_1x2(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_width(), FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_1x2_to_1x3(), and FLA_Repart_2x2_to_3x3().

Referenced by FLA_LQ_UT_form_Q().

{
  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 AR1,   AR2;

  dim_t   b, b_alg;
  dim_t   m_BR, n_BR;

  b_alg = FLA_Obj_length( T );

  // If A is longer than T is wide, then we need to position ourseves
  // carefully within the matrix for the initial partitioning.
  if ( FLA_Obj_length( 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 = 0;
    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_length( ATL ) > 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_length( A21 ), FLA_TL );

    // Use an unblocked algorithm for the first (or only) block.
    if ( FLA_Obj_length( ABR ) == 0 )
    {
      FLA_LQ_UT_form_Q_opt_var1( A11, T1T );
    }
    else
    {
      FLA_Merge_1x2( A11, A12,   &AR1 );
      FLA_Merge_1x2( A21, A22,   &AR2 );

      // Apply the block Householder transforms to A21 and A22.
      FLA_Apply_Q_UT( FLA_RIGHT, FLA_CONJ_TRANSPOSE, FLA_FORWARD, FLA_ROWWISE,
                      AR1, T1T, WTL, AR2 );

      // Apply H to the current block panel consisting of A11 and A12.
      FLA_LQ_UT_form_Q_opt_var1( AR1, 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;
}

FLA_Error FLA_LQ_UT_form_Q_opc_var1	(	int	m_A,
		int	n_A,
		scomplex *	buff_A,
		int	rs_A,
		int	cs_A,
		scomplex *	buff_T,
		int	rs_T,
		int	cs_T
	)

References bli_c0(), bli_c1(), bli_cconjv(), bli_cscalv(), BLIS_NO_CONJUGATE, FLA_Apply_H2_UT_r_opc_var1(), scomplex::imag, and scomplex::real.

Referenced by FLA_LQ_UT_form_Q_opt_var1().

{
    scomplex zero    = bli_c0();
    scomplex one     = bli_c1();
    int      min_m_n = min( m_A, n_A );
    int      i;

    for ( i = min_m_n - 1; i >= 0; --i )
    {
        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       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;

        FLA_Apply_H2_UT_r_opc_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a12t, cs_A,
                                    a21,  rs_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;

        bli_cconjv( n_ahead,
                    a12t, cs_A );

        bli_cscalv( BLIS_NO_CONJUGATE,
                    n_ahead,
                    &minus_inv_tau11,
                    a12t, cs_A );
    }

    return FLA_SUCCESS;
}

FLA_Error FLA_LQ_UT_form_Q_opd_var1	(	int	m_A,
		int	n_A,
		double *	buff_A,
		int	rs_A,
		int	cs_A,
		double *	buff_T,
		int	rs_T,
		int	cs_T
	)

References bli_d1(), bli_dscalv(), BLIS_NO_CONJUGATE, and FLA_Apply_H2_UT_r_opd_var1().

Referenced by FLA_LQ_UT_form_Q_opt_var1().

{
    double   one     = bli_d1();
    int      min_m_n = min( m_A, n_A );
    int      i;

    for ( i = min_m_n - 1; i >= 0; --i )
    {
        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       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;

        FLA_Apply_H2_UT_r_opd_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a12t, cs_A,
                                    a21,  rs_A,
                                    A22,  rs_A, cs_A );

        minus_inv_tau11 = -one / *tau11;

        *alpha11 = one + minus_inv_tau11;

        bli_dscalv( BLIS_NO_CONJUGATE,
                    n_ahead,
                    &minus_inv_tau11,
                    a12t, cs_A );
    }

    return FLA_SUCCESS;
}

FLA_Error FLA_LQ_UT_form_Q_ops_var1	(	int	m_A,
		int	n_A,
		float *	buff_A,
		int	rs_A,
		int	cs_A,
		float *	buff_T,
		int	rs_T,
		int	cs_T
	)

References bli_d1(), bli_sscalv(), BLIS_NO_CONJUGATE, and FLA_Apply_H2_UT_r_ops_var1().

Referenced by FLA_LQ_UT_form_Q_opt_var1().

{
    float    one     = bli_d1();
    int      min_m_n = min( m_A, n_A );
    int      i;

    for ( i = min_m_n - 1; i >= 0; --i )
    {
        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       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;

        FLA_Apply_H2_UT_r_ops_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a12t, cs_A,
                                    a21,  rs_A,
                                    A22,  rs_A, cs_A );

        minus_inv_tau11 = -one / *tau11;

        *alpha11 = one + minus_inv_tau11;

        bli_sscalv( BLIS_NO_CONJUGATE,
                    n_ahead,
                    &minus_inv_tau11,
                    a12t, cs_A );
    }

    return FLA_SUCCESS;
}

FLA_Error FLA_LQ_UT_form_Q_opt_var1	(	FLA_Obj	A,
		FLA_Obj	T
	)

References FLA_LQ_UT_form_Q_opc_var1(), FLA_LQ_UT_form_Q_opd_var1(), FLA_LQ_UT_form_Q_ops_var1(), FLA_LQ_UT_form_Q_opz_var1(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), and FLA_Obj_width().

Referenced by FLA_LQ_UT_form_Q_blk_var1().

{
    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_LQ_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_LQ_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_LQ_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_LQ_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;
}

FLA_Error FLA_LQ_UT_form_Q_opz_var1	(	int	m_A,
		int	n_A,
		dcomplex *	buff_A,
		int	rs_A,
		int	cs_A,
		dcomplex *	buff_T,
		int	rs_T,
		int	cs_T
	)

References bli_z0(), bli_z1(), bli_zconjv(), bli_zscalv(), BLIS_NO_CONJUGATE, FLA_Apply_H2_UT_r_opz_var1(), dcomplex::imag, and dcomplex::real.

Referenced by FLA_LQ_UT_form_Q_opt_var1().

{
    dcomplex zero    = bli_z0();
    dcomplex one     = bli_z1();
    int      min_m_n = min( m_A, n_A );
    int      i;

    for ( i = min_m_n - 1; i >= 0; --i )
    {
        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       n_ahead  = n_A - i - 1;
        int       m_ahead  = m_A - i - 1;

        FLA_Apply_H2_UT_r_opz_var1( m_ahead,
                                    n_ahead,
                                    tau11,
                                    a12t, cs_A,
                                    a21,  rs_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;

        bli_zconjv( n_ahead,
                    a12t, cs_A );

        bli_zscalv( BLIS_NO_CONJUGATE,
                    n_ahead,
                    &minus_inv_tau11,
                    a12t, cs_A );
    }

    return FLA_SUCCESS;
}