bli_ger.c File Reference

(r)

Functions
void	bli_sger (conj_t conjx, conj_t conjy, int m, int n, float *alpha, float *x, int incx, float *y, int incy, float *a, int a_rs, int a_cs)
void	bli_dger (conj_t conjx, conj_t conjy, int m, int n, double *alpha, double *x, int incx, double *y, int incy, double *a, int a_rs, int a_cs)
void	bli_cger (conj_t conjx, conj_t conjy, int m, int n, scomplex *alpha, scomplex *x, int incx, scomplex *y, int incy, scomplex *a, int a_rs, int a_cs)
void	bli_zger (conj_t conjx, conj_t conjy, int m, int n, dcomplex *alpha, dcomplex *x, int incx, dcomplex *y, int incy, dcomplex *a, int a_rs, int a_cs)
void	bli_sger_blas (int m, int n, float *alpha, float *x, int incx, float *y, int incy, float *a, int lda)
void	bli_dger_blas (int m, int n, double *alpha, double *x, int incx, double *y, int incy, double *a, int lda)
void	bli_cgerc_blas (int m, int n, scomplex *alpha, scomplex *x, int incx, scomplex *y, int incy, scomplex *a, int lda)
void	bli_cgeru_blas (int m, int n, scomplex *alpha, scomplex *x, int incx, scomplex *y, int incy, scomplex *a, int lda)
void	bli_zgerc_blas (int m, int n, dcomplex *alpha, dcomplex *x, int incx, dcomplex *y, int incy, dcomplex *a, int lda)
void	bli_zgeru_blas (int m, int n, dcomplex *alpha, dcomplex *x, int incx, dcomplex *y, int incy, dcomplex *a, int lda)

---

Function Documentation

void bli_cger	(	conj_t	conjx,
		conj_t	conjy,
		int	m,
		int	n,
		scomplex *	alpha,
		scomplex *	x,
		int	incx,
		scomplex *	y,
		int	incy,
		scomplex *	a,
		int	a_rs,
		int	a_cs
	)

References bli_callocv(), bli_ccopyv(), bli_ccreate_contigm(), bli_cfree(), bli_cfree_saved_contigm(), bli_cgerc_blas(), bli_cgeru_blas(), bli_is_conj(), bli_is_row_storage(), bli_zero_dim2(), and BLIS_CONJUGATE.

Referenced by FLA_Apply_H2_UT_l_opc_var1(), FLA_Apply_H2_UT_r_opc_var1(), FLA_Apply_HUD_UT_l_opc_var1(), FLA_Bidiag_UT_u_step_ofc_var3(), FLA_Bidiag_UT_u_step_opc_var2(), FLA_Bidiag_UT_u_step_opc_var3(), FLA_Eig_gest_il_opc_var3(), FLA_Eig_gest_il_opc_var4(), FLA_Eig_gest_iu_opc_var3(), FLA_Eig_gest_iu_opc_var4(), FLA_Eig_gest_nl_opc_var4(), FLA_Eig_gest_nu_opc_var4(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hess_UT_step_ofc_var2(), FLA_Hess_UT_step_ofc_var3(), FLA_Hess_UT_step_ofc_var4(), FLA_Hess_UT_step_opc_var2(), FLA_Hess_UT_step_opc_var3(), FLA_Hess_UT_step_opc_var4(), FLA_LU_nopiv_opc_var5(), FLA_LU_piv_opc_var5(), FLA_Lyap_h_opc_var2(), FLA_Lyap_n_opc_var2(), FLA_SA_LU_unb(), FLA_Trinv_ln_opc_var3(), FLA_Trinv_ln_opc_var4(), FLA_Trinv_lu_opc_var3(), FLA_Trinv_lu_opc_var4(), FLA_Trinv_un_opc_var3(), FLA_Trinv_un_opc_var4(), FLA_Trinv_uu_opc_var3(), and FLA_Trinv_uu_opc_var4().

{
    int       m_save    = m;
    int       n_save    = n;
    scomplex* a_save    = a;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    scomplex* x_conj;
    int       incx_conj;
    int       lda, inca;

    // Return early if possible.
    if ( bli_zero_dim2( m, n ) ) return;

    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of the matrix rather than the original matrix.
    bli_ccreate_contigm( m,
                         n,
                         a_save, a_rs_save, a_cs_save,
                         &a,     &a_rs,     &a_cs );

    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;

    // If A is a row-major matrix, then we can use the underlying column-major
    // BLAS implementation by fiddling with the parameters.
    if ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( m, n );
        bli_swap_ints( lda, inca );
        bli_swap_ints( incx, incy );
        bli_swap_conj( conjx, conjy );
        bli_cswap_pointers( x, y );
    }

    // Initialize with values assuming no conjugation of x.
    x_conj    = x;
    incx_conj = incx;

    // We need a temporary vector for the cases when x is conjugated.
    if ( bli_is_conj( conjx ) )
    {
        x_conj    = bli_callocv( m );
        incx_conj = 1;

        bli_ccopyv( BLIS_CONJUGATE,
                    m,
                    x,      incx,
                    x_conj, incx_conj );
    }

    // Conjugation of y is supported in the BLAS.
    if ( bli_is_conj( conjy ) )
    {
        bli_cgerc_blas( m,
                        n,
                        alpha,
                        x_conj, incx_conj,
                        y,      incy, 
                        a,      lda );
    }
    else
    {
        bli_cgeru_blas( m,
                        n,
                        alpha,
                        x_conj, incx_conj,
                        y,      incy, 
                        a,      lda );
    }

    // Free the temporary conjugated x vector.
    if ( bli_is_conj( conjx ) )
        bli_cfree( x_conj );

    // Free the temporary contiguous matrix.
    bli_cfree_saved_contigm( m_save,
                             n_save,
                             a_save, a_rs_save, a_cs_save,
                             &a,     &a_rs,     &a_cs );
}

void bli_cgerc_blas	(	int	m,
		int	n,
		scomplex *	alpha,
		scomplex *	x,
		int	incx,
		scomplex *	y,
		int	incy,
		scomplex *	a,
		int	lda
	)

References cblas_cgerc(), CblasColMajor, and F77_cgerc().

Referenced by bli_cger().

{
#ifdef BLIS_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;

    cblas_cgerc( cblas_order,
                 m,
                 n,
                 alpha,
                 x, incx,
                 y, incy,
                 a, lda );
#else
    F77_cgerc ( &m,
                &n,
                alpha,
                x, &incx,
                y, &incy,
                a, &lda );
#endif
}

void bli_cgeru_blas	(	int	m,
		int	n,
		scomplex *	alpha,
		scomplex *	x,
		int	incx,
		scomplex *	y,
		int	incy,
		scomplex *	a,
		int	lda
	)

References cblas_cgeru(), CblasColMajor, and F77_cgeru().

Referenced by bli_cger().

{
#ifdef BLIS_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;

    cblas_cgeru( cblas_order,
                 m,
                 n,
                 alpha,
                 x, incx,
                 y, incy,
                 a, lda );
#else
    F77_cgeru ( &m,
                &n,
                alpha,
                x, &incx,
                y, &incy,
                a, &lda );
#endif
}

void bli_dger	(	conj_t	conjx,
		conj_t	conjy,
		int	m,
		int	n,
		double *	alpha,
		double *	x,
		int	incx,
		double *	y,
		int	incy,
		double *	a,
		int	a_rs,
		int	a_cs
	)

References bli_dcreate_contigm(), bli_dfree_saved_contigm(), bli_dger_blas(), bli_is_row_storage(), and bli_zero_dim2().

Referenced by FLA_Apply_H2_UT_l_opd_var1(), FLA_Apply_H2_UT_r_opd_var1(), FLA_Apply_HUD_UT_l_opd_var1(), FLA_Bidiag_UT_u_step_ofd_var3(), FLA_Bidiag_UT_u_step_opd_var2(), FLA_Bidiag_UT_u_step_opd_var3(), FLA_Eig_gest_il_opd_var3(), FLA_Eig_gest_il_opd_var4(), FLA_Eig_gest_iu_opd_var3(), FLA_Eig_gest_iu_opd_var4(), FLA_Eig_gest_nl_opd_var4(), FLA_Eig_gest_nu_opd_var4(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hess_UT_step_ofd_var2(), FLA_Hess_UT_step_ofd_var3(), FLA_Hess_UT_step_ofd_var4(), FLA_Hess_UT_step_opd_var2(), FLA_Hess_UT_step_opd_var3(), FLA_Hess_UT_step_opd_var4(), FLA_LU_nopiv_opd_var5(), FLA_LU_piv_opd_var5(), FLA_Lyap_h_opd_var2(), FLA_Lyap_n_opd_var2(), FLA_SA_LU_unb(), FLA_Trinv_ln_opd_var3(), FLA_Trinv_ln_opd_var4(), FLA_Trinv_lu_opd_var3(), FLA_Trinv_lu_opd_var4(), FLA_Trinv_un_opd_var3(), FLA_Trinv_un_opd_var4(), FLA_Trinv_uu_opd_var3(), and FLA_Trinv_uu_opd_var4().

{
    int       m_save    = m;
    int       n_save    = n;
    double*   a_save    = a;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    int       lda, inca;

    // Return early if possible.
    if ( bli_zero_dim2( m, n ) ) return;

    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of the matrix rather than the original matrix.
    bli_dcreate_contigm( m,
                         n,
                         a_save, a_rs_save, a_cs_save,
                         &a,     &a_rs,     &a_cs );

    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;

    // If A is a row-major matrix, then we can use the underlying column-major
    // BLAS implementation by fiddling with the parameters.
    if ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( m, n );
        bli_swap_ints( lda, inca );
        bli_swap_ints( incx, incy );
        bli_swap_conj( conjx, conjy );
        bli_dswap_pointers( x, y );
    }

    // Initialize with values assuming no conjugation of x.
    bli_dger_blas( m,
                   n,
                   alpha,
                   x, incx,
                   y, incy,
                   a, lda );

    // Free the temporary contiguous matrix.
    bli_dfree_saved_contigm( m_save,
                             n_save,
                             a_save, a_rs_save, a_cs_save,
                             &a,     &a_rs,     &a_cs );
}

void bli_dger_blas	(	int	m,
		int	n,
		double *	alpha,
		double *	x,
		int	incx,
		double *	y,
		int	incy,
		double *	a,
		int	lda
	)

References cblas_dger(), CblasColMajor, and F77_dger().

Referenced by bli_dger().

{
#ifdef BLIS_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;

    cblas_dger( cblas_order,
                m,
                n,
                *alpha,
                x, incx,
                y, incy,
                a, lda );
#else
    F77_dger( &m,
              &n,
              alpha,
              x, &incx,
              y, &incy,
              a, &lda );
#endif
}

void bli_sger	(	conj_t	conjx,
		conj_t	conjy,
		int	m,
		int	n,
		float *	alpha,
		float *	x,
		int	incx,
		float *	y,
		int	incy,
		float *	a,
		int	a_rs,
		int	a_cs
	)

References bli_is_row_storage(), bli_screate_contigm(), bli_sfree_saved_contigm(), bli_sger_blas(), and bli_zero_dim2().

Referenced by FLA_Apply_H2_UT_l_ops_var1(), FLA_Apply_H2_UT_r_ops_var1(), FLA_Apply_HUD_UT_l_ops_var1(), FLA_Bidiag_UT_u_step_ofs_var3(), FLA_Bidiag_UT_u_step_ops_var2(), FLA_Bidiag_UT_u_step_ops_var3(), FLA_Eig_gest_il_ops_var3(), FLA_Eig_gest_il_ops_var4(), FLA_Eig_gest_iu_ops_var3(), FLA_Eig_gest_iu_ops_var4(), FLA_Eig_gest_nl_ops_var4(), FLA_Eig_gest_nu_ops_var4(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hess_UT_step_ofs_var2(), FLA_Hess_UT_step_ofs_var3(), FLA_Hess_UT_step_ofs_var4(), FLA_Hess_UT_step_ops_var2(), FLA_Hess_UT_step_ops_var3(), FLA_Hess_UT_step_ops_var4(), FLA_LU_nopiv_ops_var5(), FLA_LU_piv_ops_var5(), FLA_Lyap_h_ops_var2(), FLA_Lyap_n_ops_var2(), FLA_SA_LU_unb(), FLA_Trinv_ln_ops_var3(), FLA_Trinv_ln_ops_var4(), FLA_Trinv_lu_ops_var3(), FLA_Trinv_lu_ops_var4(), FLA_Trinv_un_ops_var3(), FLA_Trinv_un_ops_var4(), FLA_Trinv_uu_ops_var3(), and FLA_Trinv_uu_ops_var4().

{
    int       m_save    = m;
    int       n_save    = n;
    float*    a_save    = a;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    int       lda, inca;

    // Return early if possible.
    if ( bli_zero_dim2( m, n ) ) return;

    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of the matrix rather than the original matrix.
    bli_screate_contigm( m,
                         n,
                         a_save, a_rs_save, a_cs_save,
                         &a,     &a_rs,     &a_cs );

    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;

    // If A is a row-major matrix, then we can use the underlying column-major
    // BLAS implementation by fiddling with the parameters.
    if ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( m, n );
        bli_swap_ints( lda, inca );
        bli_swap_ints( incx, incy );
        bli_swap_conj( conjx, conjy );
        bli_sswap_pointers( x, y );
    }

    // Initialize with values assuming no conjugation of x.
    bli_sger_blas( m,
                   n,
                   alpha,
                   x, incx,
                   y, incy,
                   a, lda );

    // Free the temporary contiguous matrix.
    bli_sfree_saved_contigm( m_save,
                             n_save,
                             a_save, a_rs_save, a_cs_save,
                             &a,     &a_rs,     &a_cs );
}

void bli_sger_blas	(	int	m,
		int	n,
		float *	alpha,
		float *	x,
		int	incx,
		float *	y,
		int	incy,
		float *	a,
		int	lda
	)

References cblas_sger(), CblasColMajor, and F77_sger().

Referenced by bli_sger().

{
#ifdef BLIS_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;

    cblas_sger( cblas_order,
                m,
                n,
                *alpha,
                x, incx,
                y, incy,
                a, lda );
#else
    F77_sger( &m,
              &n,
              alpha,
              x, &incx,
              y, &incy,
              a, &lda );
#endif
}

void bli_zger	(	conj_t	conjx,
		conj_t	conjy,
		int	m,
		int	n,
		dcomplex *	alpha,
		dcomplex *	x,
		int	incx,
		dcomplex *	y,
		int	incy,
		dcomplex *	a,
		int	a_rs,
		int	a_cs
	)

References bli_is_conj(), bli_is_row_storage(), bli_zallocv(), bli_zcopyv(), bli_zcreate_contigm(), bli_zero_dim2(), bli_zfree(), bli_zfree_saved_contigm(), bli_zgerc_blas(), bli_zgeru_blas(), and BLIS_CONJUGATE.

Referenced by FLA_Apply_H2_UT_l_opz_var1(), FLA_Apply_H2_UT_r_opz_var1(), FLA_Apply_HUD_UT_l_opz_var1(), FLA_Bidiag_UT_u_step_ofz_var3(), FLA_Bidiag_UT_u_step_opz_var2(), FLA_Bidiag_UT_u_step_opz_var3(), FLA_Eig_gest_il_opz_var3(), FLA_Eig_gest_il_opz_var4(), FLA_Eig_gest_iu_opz_var3(), FLA_Eig_gest_iu_opz_var4(), FLA_Eig_gest_nl_opz_var4(), FLA_Eig_gest_nu_opz_var4(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hess_UT_step_ofz_var2(), FLA_Hess_UT_step_ofz_var3(), FLA_Hess_UT_step_ofz_var4(), FLA_Hess_UT_step_opz_var2(), FLA_Hess_UT_step_opz_var3(), FLA_Hess_UT_step_opz_var4(), FLA_LU_nopiv_opz_var5(), FLA_LU_piv_opz_var5(), FLA_Lyap_h_opz_var2(), FLA_Lyap_n_opz_var2(), FLA_SA_LU_unb(), FLA_Trinv_ln_opz_var3(), FLA_Trinv_ln_opz_var4(), FLA_Trinv_lu_opz_var3(), FLA_Trinv_lu_opz_var4(), FLA_Trinv_un_opz_var3(), FLA_Trinv_un_opz_var4(), FLA_Trinv_uu_opz_var3(), and FLA_Trinv_uu_opz_var4().

{
    int       m_save    = m;
    int       n_save    = n;
    dcomplex* a_save    = a;
    int       a_rs_save = a_rs;
    int       a_cs_save = a_cs;
    dcomplex* x_conj;
    int       incx_conj;
    int       lda, inca;

    // Return early if possible.
    if ( bli_zero_dim2( m, n ) ) return;

    // If necessary, allocate, initialize, and use a temporary contiguous
    // copy of the matrix rather than the original matrix.
    bli_zcreate_contigm( m,
                         n,
                         a_save, a_rs_save, a_cs_save,
                         &a,     &a_rs,     &a_cs );

    // Initialize with values assuming column-major storage.
    lda  = a_cs;
    inca = a_rs;

    // If A is a row-major matrix, then we can use the underlying column-major
    // BLAS implementation by fiddling with the parameters.
    if ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( m, n );
        bli_swap_ints( lda, inca );
        bli_swap_ints( incx, incy );
        bli_swap_conj( conjx, conjy );
        bli_zswap_pointers( x, y );
    }

    // Initialize with values assuming no conjugation of x.
    x_conj    = x;
    incx_conj = incx;

    // We need a temporary vector for the cases when x is conjugated.
    if ( bli_is_conj( conjx ) )
    {
        x_conj    = bli_zallocv( m );
        incx_conj = 1;

        bli_zcopyv( BLIS_CONJUGATE,
                    m,
                    x,      incx,
                    x_conj, incx_conj );
    }

    // Conjugation of y is supported in the BLAS.
    if ( bli_is_conj( conjy ) )
    {
        bli_zgerc_blas( m,
                        n,
                        alpha,
                        x_conj, incx_conj,
                        y,      incy, 
                        a,      lda );
    }
    else
    {
        bli_zgeru_blas( m,
                        n,
                        alpha,
                        x_conj, incx_conj,
                        y,      incy, 
                        a,      lda );
    }

    // Free the temporary conjugated x vector.
    if ( bli_is_conj( conjx ) )
        bli_zfree( x_conj );

    // Free the temporary contiguous matrix.
    bli_zfree_saved_contigm( m_save,
                             n_save,
                             a_save, a_rs_save, a_cs_save,
                             &a,     &a_rs,     &a_cs );
}

void bli_zgerc_blas	(	int	m,
		int	n,
		dcomplex *	alpha,
		dcomplex *	x,
		int	incx,
		dcomplex *	y,
		int	incy,
		dcomplex *	a,
		int	lda
	)

References cblas_zgerc(), CblasColMajor, and F77_zgerc().

Referenced by bli_zger().

{
#ifdef BLIS_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;

    cblas_zgerc( cblas_order,
                 m,
                 n,
                 alpha,
                 x, incx,
                 y, incy,
                 a, lda );
#else
    F77_zgerc ( &m,
                &n,
                alpha,
                x, &incx,
                y, &incy,
                a, &lda );
#endif
}

void bli_zgeru_blas	(	int	m,
		int	n,
		dcomplex *	alpha,
		dcomplex *	x,
		int	incx,
		dcomplex *	y,
		int	incy,
		dcomplex *	a,
		int	lda
	)

References cblas_zgeru(), CblasColMajor, and F77_zgeru().

Referenced by bli_zger().

{
#ifdef BLIS_ENABLE_CBLAS_INTERFACES
    enum CBLAS_ORDER cblas_order = CblasColMajor;

    cblas_zgeru( cblas_order,
                 m,
                 n,
                 alpha,
                 x, incx,
                 y, incy,
                 a, lda );
#else
    F77_zgeru ( &m,
                &n,
                alpha,
                x, &incx,
                y, &incy,
                a, &lda );
#endif
}