libflame  revision_anchor
Functions
bli_apdiagmv.c File Reference

(r)

Functions

void bli_sapdiagmv (side_t side, conj_t conj, int m, int n, float *x, int incx, float *a, int a_rs, int a_cs)
void bli_dapdiagmv (side_t side, conj_t conj, int m, int n, double *x, int incx, double *a, int a_rs, int a_cs)
void bli_csapdiagmv (side_t side, conj_t conj, int m, int n, float *x, int incx, scomplex *a, int a_rs, int a_cs)
void bli_capdiagmv (side_t side, conj_t conj, int m, int n, scomplex *x, int incx, scomplex *a, int a_rs, int a_cs)
void bli_zdapdiagmv (side_t side, conj_t conj, int m, int n, double *x, int incx, dcomplex *a, int a_rs, int a_cs)
void bli_zapdiagmv (side_t side, conj_t conj, int m, int n, dcomplex *x, int incx, dcomplex *a, int a_rs, int a_cs)

Function Documentation

void bli_capdiagmv ( side_t  side,
conj_t  conj,
int  m,
int  n,
scomplex x,
int  incx,
scomplex a,
int  a_rs,
int  a_cs 
)

References bli_cewscalv(), bli_cscalv(), bli_is_left(), bli_is_row_storage(), and bli_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

{
    scomplex* chi;
    scomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;

    // Return early if possible.
    if ( bli_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 ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem );
        bli_swap_ints( lda, inca );
        bli_toggle_side( side );
    }

    if ( bli_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;

            bli_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;
    
            bli_cscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}
void bli_csapdiagmv ( side_t  side,
conj_t  conj,
int  m,
int  n,
float *  x,
int  incx,
scomplex a,
int  a_rs,
int  a_cs 
)

References bli_csewscalv(), bli_csscalv(), bli_is_left(), bli_is_row_storage(), and bli_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

{
    float*    chi;
    scomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;

    // Return early if possible.
    if ( bli_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 ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem );
        bli_swap_ints( lda, inca );
        bli_toggle_side( side );
    }

    if ( bli_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;

            bli_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;
    
            bli_csscalv( conj,
                         n_elem,
                         chi,
                         a_begin, inca );
        }
    }
}
void bli_dapdiagmv ( side_t  side,
conj_t  conj,
int  m,
int  n,
double *  x,
int  incx,
double *  a,
int  a_rs,
int  a_cs 
)

References bli_dewscalv(), bli_dscalv(), bli_is_left(), bli_is_row_storage(), and bli_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

{
    double*   chi;
    double*   a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;

    // Return early if possible.
    if ( bli_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 ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem );
        bli_swap_ints( lda, inca );
        bli_toggle_side( side );
    }

    if ( bli_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;

            bli_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;
    
            bli_dscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}
void bli_sapdiagmv ( side_t  side,
conj_t  conj,
int  m,
int  n,
float *  x,
int  incx,
float *  a,
int  a_rs,
int  a_cs 
)

References bli_is_left(), bli_is_row_storage(), bli_sewscalv(), bli_sscalv(), and bli_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

{
    float*    chi;
    float*    a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;

    // Return early if possible.
    if ( bli_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 ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem );
        bli_swap_ints( lda, inca );
        bli_toggle_side( side );
    }

    if ( bli_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;

            bli_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;
    
            bli_sscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}
void bli_zapdiagmv ( side_t  side,
conj_t  conj,
int  m,
int  n,
dcomplex x,
int  incx,
dcomplex a,
int  a_rs,
int  a_cs 
)

References bli_is_left(), bli_is_row_storage(), bli_zero_dim2(), bli_zewscalv(), and bli_zscalv().

Referenced by FLA_Apply_diag_matrix().

{
    dcomplex* chi;
    dcomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;

    // Return early if possible.
    if ( bli_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 ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem );
        bli_swap_ints( lda, inca );
        bli_toggle_side( side );
    }

    if ( bli_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;

            bli_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;
    
            bli_zscalv( conj,
                        n_elem,
                        chi,
                        a_begin, inca );
        }
    }
}
void bli_zdapdiagmv ( side_t  side,
conj_t  conj,
int  m,
int  n,
double *  x,
int  incx,
dcomplex a,
int  a_rs,
int  a_cs 
)

References bli_is_left(), bli_is_row_storage(), bli_zdewscalv(), bli_zdscalv(), and bli_zero_dim2().

Referenced by FLA_Apply_diag_matrix().

{
    double*   chi;
    dcomplex* a_begin;
    int       inca, lda;
    int       n_iter;
    int       n_elem;
    int       j;

    // Return early if possible.
    if ( bli_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 ( bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem );
        bli_swap_ints( lda, inca );
        bli_toggle_side( side );
    }

    if ( bli_is_left( side ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            a_begin = a + j*lda;

            bli_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;
    
            bli_zdscalv( conj,
                         n_elem,
                         chi,
                         a_begin, inca );
        }
    }
}