bl1_trsm.c File Reference

(r)

Functions
void	bl1_strsm (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, float *alpha, float *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
void	bl1_dtrsm (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, double *alpha, double *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
void	bl1_ctrsm (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, scomplex *alpha, scomplex *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
void	bl1_ztrsm (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, dcomplex *alpha, dcomplex *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)
void	bl1_strsm_blas (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, float *alpha, float *a, int lda, float *b, int ldb)
void	bl1_dtrsm_blas (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, double *alpha, double *a, int lda, double *b, int ldb)
void	bl1_ctrsm_blas (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, scomplex *alpha, scomplex *a, int lda, scomplex *b, int ldb)
void	bl1_ztrsm_blas (side1_t side, uplo1_t uplo, trans1_t trans, diag1_t diag, int m, int n, dcomplex *alpha, dcomplex *a, int lda, dcomplex *b, int ldb)

Function Documentation

bl1_ctrsm()

void bl1_ctrsm	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		scomplex *	alpha,
		scomplex *	a,
		int	a_rs,
		int	a_cs,
		scomplex *	b,
		int	b_rs,
		int	b_cs
	)

{
    int       m_save    = m;
    int       n_save    = n;
    scomplex* a_save    = a;
    scomplex* b_save    = b;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    int       b_rs_save = b_rs;
    int       b_cs_save = b_cs;
    scomplex* a_conj;
    int       dim_a;
    int       lda, inca;
    int       ldb, incb;
    int       lda_conj, inca_conj;
    int       a_was_copied;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of each matrix rather than the original matrices.
    bl1_set_dim_with_side( side, m, n, &dim_a );
    bl1_ccreate_contigmr( uplo,
                          dim_a,
                          dim_a,
                          a_save, a_rs_save, a_cs_save,
                          &a,     &a_rs,     &a_cs );
 
    bl1_ccreate_contigm( m,
                         n,
                         b_save, b_rs_save, b_cs_save,
                         &b,     &b_rs,     &b_cs );
 
    // Figure out whether A was copied to contiguous memory. This is used to
    // prevent redundant copying.
    a_was_copied = ( a != a_save );
 
    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;
    ldb  = b_cs;
    incb = b_rs;
 
    // Adjust the parameters based on the storage of each matrix.
    if ( bl1_is_col_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr( uplo( A_c ) ) * B_c
            // effective operation: B_c := tr( uplo( A_c ) ) * B_c
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr(  uplo( A_r ) )   * B_c
            // effective operation: B_c := tr( ~uplo( A_c ) )^T * B_c
            bl1_swap_ints( lda, inca );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_trans( trans );
        }
    }
    else // if ( bl1_is_row_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_c ) ) * B_r
            // effective operation: B_c := B_c * tr( uplo( A_c ) )^T
            bl1_swap_ints( ldb, incb );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_side( side );
            bl1_toggle_trans( trans );
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_r ) ) * B_r
            // effective operation: B_c := B_c * tr( ~uplo( A_c ) )
            bl1_swap_ints( ldb, incb );
            bl1_swap_ints( lda, inca );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_side( side );
        }
    }
 
    // Initialize with values assuming that trans is not conjnotrans.
    a_conj    = a;
    lda_conj  = lda;
    inca_conj = inca;
 
    // We want to handle the conjnotrans case. The easiest way to do so is
    // by making a conjugated copy of A.
    if ( bl1_is_conjnotrans( trans ) && !a_was_copied )
    {
        int dim_a;
 
        bl1_set_dim_with_side( side, m, n, &dim_a );
        
        a_conj    = bl1_callocm( dim_a, dim_a );
        lda_conj  = dim_a;
        inca_conj = 1;
 
        bl1_ccopymrt( uplo,
                      BLIS1_CONJ_NO_TRANSPOSE,
                      dim_a,
                      dim_a,
                      a,      inca,      lda,
                      a_conj, inca_conj, lda_conj );
    }
    else if ( bl1_is_conjnotrans( trans ) && a_was_copied )
    {
        int dim_a;
 
        bl1_set_dim_with_side( side, m, n, &dim_a );
        
        bl1_cconjmr( uplo,
                     dim_a,
                     dim_a,
                     a_conj, inca_conj, lda_conj );
    }
 
 
    bl1_ctrsm_blas( side,
                    uplo,
                    trans,
                    diag,
                    m,
                    n,
                    alpha,
                    a_conj, lda_conj,
                    b,      ldb );
 
    if ( bl1_is_conjnotrans( trans ) && !a_was_copied )
        bl1_cfree( a_conj );
 
    // Free any temporary contiguous matrices, copying the result back to
    // the original matrix.
    bl1_cfree_contigm( a_save, a_rs_save, a_cs_save,
                       &a,     &a_rs,     &a_cs );
 
    bl1_cfree_saved_contigm( m_save,
                             n_save,
                             b_save, b_rs_save, b_cs_save,
                             &b,     &b_rs,     &b_cs );
}

References bl1_callocm(), bl1_cconjmr(), bl1_ccopymrt(), bl1_ccreate_contigm(), bl1_ccreate_contigmr(), bl1_cfree(), bl1_cfree_contigm(), bl1_cfree_saved_contigm(), bl1_ctrsm_blas(), bl1_is_col_storage(), bl1_is_conjnotrans(), bl1_set_dim_with_side(), bl1_zero_dim2(), and BLIS1_CONJ_NO_TRANSPOSE.

Referenced by bl1_ctrsmsx(), FLA_LU_nopiv_opc_var1(), FLA_LU_nopiv_opc_var2(), FLA_LU_nopiv_opc_var3(), FLA_LU_piv_opc_var3(), and FLA_Trsm_external().

bl1_ctrsm_blas()

void bl1_ctrsm_blas	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		scomplex *	alpha,
		scomplex *	a,
		int	lda,
		scomplex *	b,
		int	ldb
	)

{
#ifdef BLIS1_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;
    enum CBLAS_SIDE  cblas_side;
    enum CBLAS_UPLO  cblas_uplo;
    enum CBLAS_TRANSPOSE cblas_trans;
    enum CBLAS_DIAG  cblas_diag;
 
    bl1_param_map_to_netlib_side( side, &cblas_side );
    bl1_param_map_to_netlib_uplo( uplo, &cblas_uplo );
    bl1_param_map_to_netlib_trans( trans, &cblas_trans );
    bl1_param_map_to_netlib_diag( diag, &cblas_diag );
 
    cblas_ctrsm( cblas_order,
                 cblas_side,
                 cblas_uplo,
                 cblas_trans,
                 cblas_diag,
                 m,
                 n,
                 alpha,
                 a, lda,
                 b, ldb );
#else
    char blas_side;
    char blas_uplo;
    char blas_trans;
    char blas_diag;
 
    bl1_param_map_to_netlib_side( side, &blas_side );
    bl1_param_map_to_netlib_uplo( uplo, &blas_uplo );
    bl1_param_map_to_netlib_trans( trans, &blas_trans );
    bl1_param_map_to_netlib_diag( diag, &blas_diag );
 
    F77_ctrsm( &blas_side,
               &blas_uplo,
               &blas_trans,
               &blas_diag,
               &m,
               &n,
               alpha,
               a, &lda,
               b, &ldb );
#endif
}

References bl1_param_map_to_netlib_diag(), bl1_param_map_to_netlib_side(), bl1_param_map_to_netlib_trans(), bl1_param_map_to_netlib_uplo(), cblas_ctrsm(), CblasColMajor, and F77_ctrsm().

Referenced by bl1_ctrsm().

bl1_dtrsm()

void bl1_dtrsm	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		double *	alpha,
		double *	a,
		int	a_rs,
		int	a_cs,
		double *	b,
		int	b_rs,
		int	b_cs
	)

{
    int       m_save    = m;
    int       n_save    = n;
    double*   a_save    = a;
    double*   b_save    = b;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    int       b_rs_save = b_rs;
    int       b_cs_save = b_cs;
    int       dim_a;
    int       lda, inca;
    int       ldb, incb;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of each matrix rather than the original matrices.
    bl1_set_dim_with_side( side, m, n, &dim_a );
    bl1_dcreate_contigmr( uplo,
                          dim_a,
                          dim_a,
                          a_save, a_rs_save, a_cs_save,
                          &a,     &a_rs,     &a_cs );
 
    bl1_dcreate_contigm( m,
                         n,
                         b_save, b_rs_save, b_cs_save,
                         &b,     &b_rs,     &b_cs );
 
    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;
    ldb  = b_cs;
    incb = b_rs;
 
    // Adjust the parameters based on the storage of each matrix.
    if ( bl1_is_col_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr( uplo( A_c ) ) * B_c
            // effective operation: B_c := tr( uplo( A_c ) ) * B_c
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr(  uplo( A_r ) )   * B_c
            // effective operation: B_c := tr( ~uplo( A_c ) )^T * B_c
            bl1_swap_ints( lda, inca );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_trans( trans );
        }
    }
    else // if ( bl1_is_row_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_c ) ) * B_r
            // effective operation: B_c := B_c * tr( uplo( A_c ) )^T
            bl1_swap_ints( ldb, incb );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_side( side );
            bl1_toggle_trans( trans );
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_r ) ) * B_r
            // effective operation: B_c := B_c * tr( ~uplo( A_c ) )
            bl1_swap_ints( ldb, incb );
            bl1_swap_ints( lda, inca );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_side( side );
        }
    }
 
    bl1_dtrsm_blas( side,
                    uplo,
                    trans,
                    diag,
                    m,
                    n,
                    alpha,
                    a, lda,
                    b, ldb );
 
    // Free any temporary contiguous matrices, copying the result back to
    // the original matrix.
    bl1_dfree_contigm( a_save, a_rs_save, a_cs_save,
                       &a,     &a_rs,     &a_cs );
 
    bl1_dfree_saved_contigm( m_save,
                             n_save,
                             b_save, b_rs_save, b_cs_save,
                             &b,     &b_rs,     &b_cs );
}

References bl1_dcreate_contigm(), bl1_dcreate_contigmr(), bl1_dfree_contigm(), bl1_dfree_saved_contigm(), bl1_dtrsm_blas(), bl1_is_col_storage(), bl1_set_dim_with_side(), and bl1_zero_dim2().

Referenced by bl1_dtrsmsx(), FLA_LU_nopiv_opd_var1(), FLA_LU_nopiv_opd_var2(), FLA_LU_nopiv_opd_var3(), FLA_LU_piv_opd_var3(), and FLA_Trsm_external().

bl1_dtrsm_blas()

void bl1_dtrsm_blas	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		double *	alpha,
		double *	a,
		int	lda,
		double *	b,
		int	ldb
	)

{
#ifdef BLIS1_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;
    enum CBLAS_SIDE  cblas_side;
    enum CBLAS_UPLO  cblas_uplo;
    enum CBLAS_TRANSPOSE cblas_trans;
    enum CBLAS_DIAG  cblas_diag;
 
    bl1_param_map_to_netlib_side( side, &cblas_side );
    bl1_param_map_to_netlib_uplo( uplo, &cblas_uplo );
    bl1_param_map_to_netlib_trans( trans, &cblas_trans );
    bl1_param_map_to_netlib_diag( diag, &cblas_diag );
 
    cblas_dtrsm( cblas_order,
                 cblas_side,
                 cblas_uplo,
                 cblas_trans,
                 cblas_diag,
                 m,
                 n,
                 *alpha,
                 a, lda,
                 b, ldb );
#else
    char blas_side;
    char blas_uplo;
    char blas_trans;
    char blas_diag;
 
    bl1_param_map_to_netlib_side( side, &blas_side );
    bl1_param_map_to_netlib_uplo( uplo, &blas_uplo );
    bl1_param_map_to_netlib_trans( trans, &blas_trans );
    bl1_param_map_to_netlib_diag( diag, &blas_diag );
 
    F77_dtrsm( &blas_side,
               &blas_uplo,
               &blas_trans,
               &blas_diag,
               &m,
               &n,
               alpha,
               a, &lda,
               b, &ldb );
#endif
}

References bl1_param_map_to_netlib_diag(), bl1_param_map_to_netlib_side(), bl1_param_map_to_netlib_trans(), bl1_param_map_to_netlib_uplo(), cblas_dtrsm(), CblasColMajor, and F77_dtrsm().

Referenced by bl1_dtrsm().

bl1_strsm()

void bl1_strsm	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		float *	alpha,
		float *	a,
		int	a_rs,
		int	a_cs,
		float *	b,
		int	b_rs,
		int	b_cs
	)

{
    int       m_save    = m;
    int       n_save    = n;
    float*    a_save    = a;
    float*    b_save    = b;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    int       b_rs_save = b_rs;
    int       b_cs_save = b_cs;
    int       dim_a;
    int       lda, inca;
    int       ldb, incb;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of each matrix rather than the original matrices.
    bl1_set_dim_with_side( side, m, n, &dim_a );
    bl1_screate_contigmr( uplo,
                          dim_a,
                          dim_a,
                          a_save, a_rs_save, a_cs_save,
                          &a,     &a_rs,     &a_cs );
 
    bl1_screate_contigm( m,
                         n,
                         b_save, b_rs_save, b_cs_save,
                         &b,     &b_rs,     &b_cs );
 
    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;
    ldb  = b_cs;
    incb = b_rs;
 
    // Adjust the parameters based on the storage of each matrix.
    if ( bl1_is_col_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr( uplo( A_c ) ) * B_c
            // effective operation: B_c := tr( uplo( A_c ) ) * B_c
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr(  uplo( A_r ) )   * B_c
            // effective operation: B_c := tr( ~uplo( A_c ) )^T * B_c
            bl1_swap_ints( lda, inca );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_trans( trans );
        }
    }
    else // if ( bl1_is_row_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_c ) ) * B_r
            // effective operation: B_c := B_c * tr( uplo( A_c ) )^T
            bl1_swap_ints( ldb, incb );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_side( side );
            bl1_toggle_trans( trans );
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_r ) ) * B_r
            // effective operation: B_c := B_c * tr( ~uplo( A_c ) )
            bl1_swap_ints( ldb, incb );
            bl1_swap_ints( lda, inca );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_side( side );
        }
    }
 
    bl1_strsm_blas( side,
                    uplo,
                    trans,
                    diag,
                    m,
                    n,
                    alpha,
                    a, lda,
                    b, ldb );
 
    // Free any temporary contiguous matrices, copying the result back to
    // the original matrix.
    bl1_sfree_contigm( a_save, a_rs_save, a_cs_save,
                       &a,     &a_rs,     &a_cs );
 
    bl1_sfree_saved_contigm( m_save,
                             n_save,
                             b_save, b_rs_save, b_cs_save,
                             &b,     &b_rs,     &b_cs );
}

References bl1_is_col_storage(), bl1_screate_contigm(), bl1_screate_contigmr(), bl1_set_dim_with_side(), bl1_sfree_contigm(), bl1_sfree_saved_contigm(), bl1_strsm_blas(), and bl1_zero_dim2().

Referenced by bl1_strsmsx(), FLA_LU_nopiv_ops_var1(), FLA_LU_nopiv_ops_var2(), FLA_LU_nopiv_ops_var3(), FLA_LU_piv_ops_var3(), and FLA_Trsm_external().

bl1_strsm_blas()

void bl1_strsm_blas	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		float *	alpha,
		float *	a,
		int	lda,
		float *	b,
		int	ldb
	)

{
#ifdef BLIS1_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;
    enum CBLAS_SIDE  cblas_side;
    enum CBLAS_UPLO  cblas_uplo;
    enum CBLAS_TRANSPOSE cblas_trans;
    enum CBLAS_DIAG  cblas_diag;
 
    bl1_param_map_to_netlib_side( side, &cblas_side );
    bl1_param_map_to_netlib_uplo( uplo, &cblas_uplo );
    bl1_param_map_to_netlib_trans( trans, &cblas_trans );
    bl1_param_map_to_netlib_diag( diag, &cblas_diag );
 
    cblas_strsm( cblas_order,
                 cblas_side,
                 cblas_uplo,
                 cblas_trans,
                 cblas_diag,
                 m,
                 n,
                 *alpha,
                 a, lda,
                 b, ldb );
#else
    char blas_side;
    char blas_uplo;
    char blas_trans;
    char blas_diag;
 
    bl1_param_map_to_netlib_side( side, &blas_side );
    bl1_param_map_to_netlib_uplo( uplo, &blas_uplo );
    bl1_param_map_to_netlib_trans( trans, &blas_trans );
    bl1_param_map_to_netlib_diag( diag, &blas_diag );
 
    F77_strsm( &blas_side,
               &blas_uplo,
               &blas_trans,
               &blas_diag,
               &m,
               &n,
               alpha,
               a, &lda,
               b, &ldb );
#endif
}

References bl1_param_map_to_netlib_diag(), bl1_param_map_to_netlib_side(), bl1_param_map_to_netlib_trans(), bl1_param_map_to_netlib_uplo(), cblas_strsm(), CblasColMajor, and F77_strsm().

Referenced by bl1_strsm().

bl1_ztrsm()

void bl1_ztrsm	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		dcomplex *	alpha,
		dcomplex *	a,
		int	a_rs,
		int	a_cs,
		dcomplex *	b,
		int	b_rs,
		int	b_cs
	)

{
    int       m_save    = m;
    int       n_save    = n;
    dcomplex* a_save    = a;
    dcomplex* b_save    = b;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    int       b_rs_save = b_rs;
    int       b_cs_save = b_cs;
    dcomplex* a_conj;
    int       dim_a;
    int       lda, inca;
    int       ldb, incb;
    int       lda_conj, inca_conj;
    int       a_was_copied;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of each matrix rather than the original matrices.
    bl1_set_dim_with_side( side, m, n, &dim_a );
    bl1_zcreate_contigmr( uplo,
                          dim_a,
                          dim_a,
                          a_save, a_rs_save, a_cs_save,
                          &a,     &a_rs,     &a_cs );
 
    bl1_zcreate_contigm( m,
                         n,
                         b_save, b_rs_save, b_cs_save,
                         &b,     &b_rs,     &b_cs );
 
    // Figure out whether A was copied to contiguous memory. This is used to
    // prevent redundant copying.
    a_was_copied = ( a != a_save );
 
    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;
    ldb  = b_cs;
    incb = b_rs;
 
    // Adjust the parameters based on the storage of each matrix.
    if ( bl1_is_col_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr( uplo( A_c ) ) * B_c
            // effective operation: B_c := tr( uplo( A_c ) ) * B_c
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_c := tr(  uplo( A_r ) )   * B_c
            // effective operation: B_c := tr( ~uplo( A_c ) )^T * B_c
            bl1_swap_ints( lda, inca );
 
            bl1_toggle_uplo( uplo );
            bl1_toggle_trans( trans );
        }
    }
    else // if ( bl1_is_row_storage( b_rs, b_cs ) )
    {
        if ( bl1_is_col_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_c ) ) * B_r
            // effective operation: B_c := B_c * tr( uplo( A_c ) )^T
            bl1_swap_ints( ldb, incb );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_side( side );
            bl1_toggle_trans( trans );
        }
        else // if ( bl1_is_row_storage( a_rs, a_cs ) )
        {
            // requested operation: B_r := tr( uplo( A_r ) ) * B_r
            // effective operation: B_c := B_c * tr( ~uplo( A_c ) )
            bl1_swap_ints( ldb, incb );
            bl1_swap_ints( lda, inca );
 
            bl1_swap_ints( m, n );
 
            bl1_toggle_side( side );
            bl1_toggle_uplo( uplo );
        }
    }
 
    // Initialize with values assuming that trans is not conjnotrans.
    a_conj    = a;
    lda_conj  = lda;
    inca_conj = inca;
 
    // We want to handle the conjnotrans case. The easiest way to do so is
    // by making a conjugated copy of A.
    if ( bl1_is_conjnotrans( trans ) && !a_was_copied )
    {
        int dim_a;
 
        bl1_set_dim_with_side( side, m, n, &dim_a );
        
        a_conj    = bl1_zallocm( dim_a, dim_a );
        lda_conj  = dim_a;
        inca_conj = 1;
 
        bl1_zcopymrt( uplo,
                      BLIS1_CONJ_NO_TRANSPOSE,
                      dim_a,
                      dim_a,
                      a,      inca,      lda,
                      a_conj, inca_conj, lda_conj );
    }
    else if ( bl1_is_conjnotrans( trans ) && a_was_copied )
    {
        int dim_a;
 
        bl1_set_dim_with_side( side, m, n, &dim_a );
        
        bl1_zconjmr( uplo,
                     dim_a,
                     dim_a,
                     a_conj, inca_conj, lda_conj );
    }
 
    bl1_ztrsm_blas( side,
                    uplo,
                    trans,
                    diag,
                    m,
                    n,
                    alpha,
                    a_conj, lda_conj,
                    b,      ldb );
 
    if ( bl1_is_conjnotrans( trans ) && !a_was_copied )
        bl1_zfree( a_conj );
 
    // Free any temporary contiguous matrices, copying the result back to
    // the original matrix.
    bl1_zfree_contigm( a_save, a_rs_save, a_cs_save,
                       &a,     &a_rs,     &a_cs );
 
    bl1_zfree_saved_contigm( m_save,
                             n_save,
                             b_save, b_rs_save, b_cs_save,
                             &b,     &b_rs,     &b_cs );
}

References bl1_is_col_storage(), bl1_is_conjnotrans(), bl1_set_dim_with_side(), bl1_zallocm(), bl1_zconjmr(), bl1_zcopymrt(), bl1_zcreate_contigm(), bl1_zcreate_contigmr(), bl1_zero_dim2(), bl1_zfree(), bl1_zfree_contigm(), bl1_zfree_saved_contigm(), bl1_ztrsm_blas(), and BLIS1_CONJ_NO_TRANSPOSE.

Referenced by bl1_ztrsmsx(), FLA_LU_nopiv_opz_var1(), FLA_LU_nopiv_opz_var2(), FLA_LU_nopiv_opz_var3(), FLA_LU_piv_opz_var3(), and FLA_Trsm_external().

bl1_ztrsm_blas()

void bl1_ztrsm_blas	(	side1_t	side,
		uplo1_t	uplo,
		trans1_t	trans,
		diag1_t	diag,
		int	m,
		int	n,
		dcomplex *	alpha,
		dcomplex *	a,
		int	lda,
		dcomplex *	b,
		int	ldb
	)

{
#ifdef BLIS1_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;
    enum CBLAS_SIDE  cblas_side;
    enum CBLAS_UPLO  cblas_uplo;
    enum CBLAS_TRANSPOSE cblas_trans;
    enum CBLAS_DIAG  cblas_diag;
 
    bl1_param_map_to_netlib_side( side, &cblas_side );
    bl1_param_map_to_netlib_uplo( uplo, &cblas_uplo );
    bl1_param_map_to_netlib_trans( trans, &cblas_trans );
    bl1_param_map_to_netlib_diag( diag, &cblas_diag );
 
    cblas_ztrsm( cblas_order,
                 cblas_side,
                 cblas_uplo,
                 cblas_trans,
                 cblas_diag,
                 m,
                 n,
                 alpha,
                 a, lda,
                 b, ldb );
#else
    char blas_side;
    char blas_uplo;
    char blas_trans;
    char blas_diag;
 
    bl1_param_map_to_netlib_side( side, &blas_side );
    bl1_param_map_to_netlib_uplo( uplo, &blas_uplo );
    bl1_param_map_to_netlib_trans( trans, &blas_trans );
    bl1_param_map_to_netlib_diag( diag, &blas_diag );
 
    F77_ztrsm( &blas_side,
               &blas_uplo,
               &blas_trans,
               &blas_diag,
               &m,
               &n,
               alpha,
               a, &lda,
               b, &ldb );
#endif
}

References bl1_param_map_to_netlib_diag(), bl1_param_map_to_netlib_side(), bl1_param_map_to_netlib_trans(), bl1_param_map_to_netlib_uplo(), cblas_ztrsm(), CblasColMajor, and F77_ztrsm().

Referenced by bl1_ztrsm().