libflame  revision_anchor
Functions
bli_copymr.c File Reference

(r)

Functions

void bli_scopymr (uplo_t uplo, int m, int n, float *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
void bli_dcopymr (uplo_t uplo, int m, int n, double *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
void bli_ccopymr (uplo_t uplo, int m, int n, scomplex *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
void bli_zcopymr (uplo_t uplo, int m, int n, dcomplex *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)
void bli_sscopymr (uplo_t uplo, int m, int n, float *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
void bli_sdcopymr (uplo_t uplo, int m, int n, float *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
void bli_dscopymr (uplo_t uplo, int m, int n, double *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
void bli_sccopymr (uplo_t uplo, int m, int n, float *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
void bli_cscopymr (uplo_t uplo, int m, int n, scomplex *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
void bli_szcopymr (uplo_t uplo, int m, int n, float *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)
void bli_zscopymr (uplo_t uplo, int m, int n, dcomplex *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
void bli_ddcopymr (uplo_t uplo, int m, int n, double *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
void bli_dccopymr (uplo_t uplo, int m, int n, double *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
void bli_cdcopymr (uplo_t uplo, int m, int n, scomplex *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
void bli_dzcopymr (uplo_t uplo, int m, int n, double *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)
void bli_zdcopymr (uplo_t uplo, int m, int n, dcomplex *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
void bli_cccopymr (uplo_t uplo, int m, int n, scomplex *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
void bli_czcopymr (uplo_t uplo, int m, int n, scomplex *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)
void bli_zccopymr (uplo_t uplo, int m, int n, dcomplex *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
void bli_zzcopymr (uplo_t uplo, int m, int n, dcomplex *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)

Function Documentation

void bli_cccopymr ( uplo_t  uplo,
int  m,
int  n,
scomplex a,
int  a_rs,
int  a_cs,
scomplex b,
int  b_rs,
int  b_cs 
)

References bli_ccopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

{
    scomplex* a_begin;
    scomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_ccopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_ccopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
}
void bli_ccopymr ( uplo_t  uplo,
int  m,
int  n,
scomplex a,
int  a_rs,
int  a_cs,
scomplex b,
int  b_rs,
int  b_cs 
)

References bli_ccopy(), bli_is_row_storage(), bli_is_upper(), and bli_zero_dim2().

Referenced by bli_ccreate_contigmr(), bli_cfree_saved_contigmr(), and FLA_Copyr_external().

{
    scomplex* a_begin;
    scomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if A and B are both row-major, then let's access the
    // matrices by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) && bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_ccopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_ccopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
}
void bli_cdcopymr ( uplo_t  uplo,
int  m,
int  n,
scomplex a,
int  a_rs,
int  a_cs,
double *  b,
int  b_rs,
int  b_cs 
)

References bli_cdcopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    scomplex* a_begin;
    double*   b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_cdcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_cdcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_cscopymr ( uplo_t  uplo,
int  m,
int  n,
scomplex a,
int  a_rs,
int  a_cs,
float *  b,
int  b_rs,
int  b_cs 
)

References bli_cscopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    scomplex* a_begin;
    float*    b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_cscopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_cscopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_czcopymr ( uplo_t  uplo,
int  m,
int  n,
scomplex a,
int  a_rs,
int  a_cs,
dcomplex b,
int  b_rs,
int  b_cs 
)

References bli_czcopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    scomplex* a_begin;
    dcomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_czcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_czcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_dccopymr ( uplo_t  uplo,
int  m,
int  n,
double *  a,
int  a_rs,
int  a_cs,
scomplex b,
int  b_rs,
int  b_cs 
)

References bli_dccopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    double*   a_begin;
    scomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_dccopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_dccopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_dcopymr ( uplo_t  uplo,
int  m,
int  n,
double *  a,
int  a_rs,
int  a_cs,
double *  b,
int  b_rs,
int  b_cs 
)

References bli_dcopy(), bli_is_row_storage(), bli_is_upper(), and bli_zero_dim2().

Referenced by bli_dcreate_contigmr(), bli_dfree_saved_contigmr(), and FLA_Copyr_external().

{
    double*   a_begin;
    double*   b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if A and B are both row-major, then let's access the
    // matrices by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) && bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_dcopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_dcopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
}
void bli_ddcopymr ( uplo_t  uplo,
int  m,
int  n,
double *  a,
int  a_rs,
int  a_cs,
double *  b,
int  b_rs,
int  b_cs 
)

References bli_dcopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

{
    double*   a_begin;
    double*   b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_dcopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_dcopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
}
void bli_dscopymr ( uplo_t  uplo,
int  m,
int  n,
double *  a,
int  a_rs,
int  a_cs,
float *  b,
int  b_rs,
int  b_cs 
)

References bli_dscopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    double*   a_begin;
    float*    b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_dscopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_dscopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_dzcopymr ( uplo_t  uplo,
int  m,
int  n,
double *  a,
int  a_rs,
int  a_cs,
dcomplex b,
int  b_rs,
int  b_cs 
)

References bli_dzcopyv(), bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    double*   a_begin;
    dcomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_dzcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_dzcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_sccopymr ( uplo_t  uplo,
int  m,
int  n,
float *  a,
int  a_rs,
int  a_cs,
scomplex b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_sccopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    float*    a_begin;
    scomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_sccopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_sccopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_scopymr ( uplo_t  uplo,
int  m,
int  n,
float *  a,
int  a_rs,
int  a_cs,
float *  b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_scopy(), and bli_zero_dim2().

Referenced by bli_screate_contigmr(), bli_sfree_saved_contigmr(), and FLA_Copyr_external().

{
    float*    a_begin;
    float*    b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if A and B are both row-major, then let's access the
    // matrices by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) && bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_scopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_scopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
}
void bli_sdcopymr ( uplo_t  uplo,
int  m,
int  n,
float *  a,
int  a_rs,
int  a_cs,
double *  b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_sdcopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    float*    a_begin;
    double*   b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_sdcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_sdcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_sscopymr ( uplo_t  uplo,
int  m,
int  n,
float *  a,
int  a_rs,
int  a_cs,
float *  b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_scopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

{
    float*    a_begin;
    float*    b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_scopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_scopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
}
void bli_szcopymr ( uplo_t  uplo,
int  m,
int  n,
float *  a,
int  a_rs,
int  a_cs,
dcomplex b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_szcopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    float*    a_begin;
    dcomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_szcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_szcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_zccopymr ( uplo_t  uplo,
int  m,
int  n,
dcomplex a,
int  a_rs,
int  a_cs,
scomplex b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_zccopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    dcomplex* a_begin;
    scomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_zccopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_zccopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_zcopymr ( uplo_t  uplo,
int  m,
int  n,
dcomplex a,
int  a_rs,
int  a_cs,
dcomplex b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_zcopy(), and bli_zero_dim2().

Referenced by bli_zcreate_contigmr(), bli_zfree_saved_contigmr(), bli_zfree_saved_contigmsr(), and FLA_Copyr_external().

{
    dcomplex* a_begin;
    dcomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if A and B are both row-major, then let's access the
    // matrices by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) && bli_is_row_storage( a_rs, a_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_zcopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_zcopy( n_elem,
                       a_begin, inca, 
                       b_begin, incb );
        }
    }
}
void bli_zdcopymr ( uplo_t  uplo,
int  m,
int  n,
dcomplex a,
int  a_rs,
int  a_cs,
double *  b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_zdcopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    dcomplex* a_begin;
    double*   b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_zdcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_zdcopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_zscopymr ( uplo_t  uplo,
int  m,
int  n,
dcomplex a,
int  a_rs,
int  a_cs,
float *  b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_zero_dim2(), bli_zscopyv(), and BLIS_NO_TRANSPOSE.

Referenced by FLA_Copyr_external().

{
    dcomplex* a_begin;
    float*    b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_zscopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_zscopyv( BLIS_NO_TRANSPOSE,
                         n_elem,
                         a_begin, inca, 
                         b_begin, incb );
        }
    }
}
void bli_zzcopymr ( uplo_t  uplo,
int  m,
int  n,
dcomplex a,
int  a_rs,
int  a_cs,
dcomplex b,
int  b_rs,
int  b_cs 
)

References bli_is_row_storage(), bli_is_upper(), bli_zcopyv(), bli_zero_dim2(), and BLIS_NO_TRANSPOSE.

{
    dcomplex* a_begin;
    dcomplex* b_begin;
    int       lda, inca;
    int       ldb, incb;
    int       n_iter;
    int       n_elem_max;
    int       n_elem;
    int       j;

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

    // We initialize for column-major.
    n_iter     = n;
    n_elem_max = m;
    lda        = a_cs;
    inca       = a_rs;
    ldb        = b_cs;
    incb       = b_rs;

    // An optimization: if B is row-major, then let's access the matrix
    // by rows instead of by columns for increased spatial locality.
    if ( bli_is_row_storage( b_rs, b_cs ) )
    {
        bli_swap_ints( n_iter, n_elem_max );
        bli_swap_ints( lda, inca );
        bli_swap_ints( ldb, incb );
        bli_toggle_uplo( uplo );
    }
    
    
    if ( bli_is_upper( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_min( j + 1, n_elem_max );
            a_begin = a + j*lda;
            b_begin = b + j*ldb;

            bli_zcopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
    else // if ( bli_is_lower( uplo ) )
    {
        for ( j = 0; j < n_iter; j++ )
        {
            n_elem  = bli_max( 0, n_elem_max - j );
            a_begin = a + j*lda + j*inca;
            b_begin = b + j*ldb + j*incb;

            if ( n_elem <= 0 ) break;

            bli_zcopyv( BLIS_NO_TRANSPOSE,
                        n_elem,
                        a_begin, inca, 
                        b_begin, incb );
        }
    }
}