bl1_apdiagmv.c File Reference

(r)

Functions
void	bl1_sapdiagmv (side1_t side, conj1_t conj, int m, int n, float *x, int incx, float *a, int a_rs, int a_cs)
void	bl1_dapdiagmv (side1_t side, conj1_t conj, int m, int n, double *x, int incx, double *a, int a_rs, int a_cs)
void	bl1_csapdiagmv (side1_t side, conj1_t conj, int m, int n, float *x, int incx, scomplex *a, int a_rs, int a_cs)
void	bl1_capdiagmv (side1_t side, conj1_t conj, int m, int n, scomplex *x, int incx, scomplex *a, int a_rs, int a_cs)
void	bl1_zdapdiagmv (side1_t side, conj1_t conj, int m, int n, double *x, int incx, dcomplex *a, int a_rs, int a_cs)
void	bl1_zapdiagmv (side1_t side, conj1_t conj, int m, int n, dcomplex *x, int incx, dcomplex *a, int a_rs, int a_cs)

Function Documentation

bl1_capdiagmv()

void bl1_capdiagmv	(	side1_t	side,
		conj1_t	conj,
		int	m,
		int	n,
		scomplex *	x,
		int	incx,
		scomplex *	a,
		int	a_rs,
		int	a_cs
	)

{
    scomplex* chi;
    scomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // Initialize with optimal values for column-major storage.
    inca   = a_rs;
    lda    = a_cs;
    n_iter = n;
    n_elem = m;
 
    // An optimization: if A is row-major, then we can proceed as if the
    // operation were transposed (applying the diagonal values in x from the
    // opposite side) for increased spatial locality.
    if ( bl1_is_row_storage( a_rs, a_cs ) )
    {
        bl1_swap_ints( n_iter, n_elem );
        bl1_swap_ints( lda, inca );
        bl1_toggle_side( side );
    }
 
    if ( bl1_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
 
            bl1_cewscalv( conj,
                          n_elem,
                          x,       incx,
                          a_begin, inca );
        }
    }
    else
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
            chi     = x + j*incx;
    
            bl1_cscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}

References bl1_cewscalv(), bl1_cscalv(), bl1_is_left(), bl1_is_row_storage(), and bl1_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

bl1_csapdiagmv()

void bl1_csapdiagmv	(	side1_t	side,
		conj1_t	conj,
		int	m,
		int	n,
		float *	x,
		int	incx,
		scomplex *	a,
		int	a_rs,
		int	a_cs
	)

{
    float*    chi;
    scomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // Initialize with optimal values for column-major storage.
    inca   = a_rs;
    lda    = a_cs;
    n_iter = n;
    n_elem = m;
 
    // An optimization: if A is row-major, then we can proceed as if the
    // operation were transposed (applying the diagonal values in x from the
    // opposite side) for increased spatial locality.
    if ( bl1_is_row_storage( a_rs, a_cs ) )
    {
        bl1_swap_ints( n_iter, n_elem );
        bl1_swap_ints( lda, inca );
        bl1_toggle_side( side );
    }
 
    if ( bl1_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
 
            bl1_csewscalv( conj,
                           n_elem,
                           x,       incx,
                           a_begin, inca );
        }
    }
    else
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
            chi     = x + j*incx;
    
            bl1_csscalv( conj,
                         n_elem,
                         chi,
                         a_begin, inca );
        }
    }
}

References bl1_csewscalv(), bl1_csscalv(), bl1_is_left(), bl1_is_row_storage(), and bl1_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

bl1_dapdiagmv()

void bl1_dapdiagmv	(	side1_t	side,
		conj1_t	conj,
		int	m,
		int	n,
		double *	x,
		int	incx,
		double *	a,
		int	a_rs,
		int	a_cs
	)

{
    double*   chi;
    double*   a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // Initialize with optimal values for column-major storage.
    inca   = a_rs;
    lda    = a_cs;
    n_iter = n;
    n_elem = m;
 
    // An optimization: if A is row-major, then we can proceed as if the
    // operation were transposed (applying the diagonal values in x from the
    // opposite side) for increased spatial locality.
    if ( bl1_is_row_storage( a_rs, a_cs ) )
    {
        bl1_swap_ints( n_iter, n_elem );
        bl1_swap_ints( lda, inca );
        bl1_toggle_side( side );
    }
 
    if ( bl1_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
 
            bl1_dewscalv( conj,
                          n_elem,
                          x,       incx,
                          a_begin, inca );
        }
    }
    else
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
            chi     = x + j*incx;
    
            bl1_dscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}

References bl1_dewscalv(), bl1_dscalv(), bl1_is_left(), bl1_is_row_storage(), and bl1_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

bl1_sapdiagmv()

void bl1_sapdiagmv	(	side1_t	side,
		conj1_t	conj,
		int	m,
		int	n,
		float *	x,
		int	incx,
		float *	a,
		int	a_rs,
		int	a_cs
	)

{
    float*    chi;
    float*    a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // Initialize with optimal values for column-major storage.
    inca   = a_rs;
    lda    = a_cs;
    n_iter = n;
    n_elem = m;
 
    // An optimization: if A is row-major, then we can proceed as if the
    // operation were transposed (applying the diagonal values in x from the
    // opposite side) for increased spatial locality.
    if ( bl1_is_row_storage( a_rs, a_cs ) )
    {
        bl1_swap_ints( n_iter, n_elem );
        bl1_swap_ints( lda, inca );
        bl1_toggle_side( side );
    }
 
    if ( bl1_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
 
            bl1_sewscalv( conj,
                          n_elem,
                          x,       incx,
                          a_begin, inca );
        }
    }
    else
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
            chi     = x + j*incx;
    
            bl1_sscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}

References bl1_is_left(), bl1_is_row_storage(), bl1_sewscalv(), bl1_sscalv(), and bl1_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

bl1_zapdiagmv()

void bl1_zapdiagmv	(	side1_t	side,
		conj1_t	conj,
		int	m,
		int	n,
		dcomplex *	x,
		int	incx,
		dcomplex *	a,
		int	a_rs,
		int	a_cs
	)

{
    dcomplex* chi;
    dcomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // Initialize with optimal values for column-major storage.
    inca   = a_rs;
    lda    = a_cs;
    n_iter = n;
    n_elem = m;
 
    // An optimization: if A is row-major, then we can proceed as if the
    // operation were transposed (applying the diagonal values in x from the
    // opposite side) for increased spatial locality.
    if ( bl1_is_row_storage( a_rs, a_cs ) )
    {
        bl1_swap_ints( n_iter, n_elem );
        bl1_swap_ints( lda, inca );
        bl1_toggle_side( side );
    }
 
    if ( bl1_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
 
            bl1_zewscalv( conj,
                          n_elem,
                          x,       incx,
                          a_begin, inca );
        }
    }
    else
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
            chi     = x + j*incx;
    
            bl1_zscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}

References bl1_is_left(), bl1_is_row_storage(), bl1_zero_dim2(), bl1_zewscalv(), and bl1_zscalv().

Referenced by FLA_Apply_diag_matrix().

bl1_zdapdiagmv()

void bl1_zdapdiagmv	(	side1_t	side,
		conj1_t	conj,
		int	m,
		int	n,
		double *	x,
		int	incx,
		dcomplex *	a,
		int	a_rs,
		int	a_cs
	)

{
    double*   chi;
    dcomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;
 
    // Return early if possible.
    if ( bl1_zero_dim2( m, n ) ) return;
 
    // Initialize with optimal values for column-major storage.
    inca   = a_rs;
    lda    = a_cs;
    n_iter = n;
    n_elem = m;
 
    // An optimization: if A is row-major, then we can proceed as if the
    // operation were transposed (applying the diagonal values in x from the
    // opposite side) for increased spatial locality.
    if ( bl1_is_row_storage( a_rs, a_cs ) )
    {
        bl1_swap_ints( n_iter, n_elem );
        bl1_swap_ints( lda, inca );
        bl1_toggle_side( side );
    }
 
    if ( bl1_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
 
            bl1_zdewscalv( conj,
                           n_elem,
                           x,       incx,
                           a_begin, inca );
        }
    }
    else
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;
            chi     = x + j*incx;
    
            bl1_zdscalv( conj,
                         n_elem,
                         chi,
                         a_begin, inca );
        }
    }
}

References bl1_is_left(), bl1_is_row_storage(), bl1_zdewscalv(), bl1_zdscalv(), and bl1_zero_dim2().

Referenced by FLA_Apply_diag_matrix().