void bli_hemv_unf_var1a( conj_t conjh,
obj_t* alpha,
obj_t* a,
obj_t* x,
obj_t* beta,
obj_t* y,
hemv_t* cntl )
{
num_t dt_a = bli_obj_datatype( *a );
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
uplo_t uplo = bli_obj_uplo( *a );
conj_t conja = bli_obj_conj_status( *a );
conj_t conjx = bli_obj_conj_status( *x );
dim_t m = bli_obj_length( *a );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t incx = bli_obj_vector_inc( *x );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t incy = bli_obj_vector_inc( *y );
num_t dt_alpha;
void* buf_alpha;
num_t dt_beta;
void* buf_beta;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of a and x. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_a, dt_x );
buf_alpha = bli_obj_scalar_buffer( dt_alpha, *alpha );
// The datatype of beta MUST be the same as the datatype of y.
dt_beta = dt_y;
buf_beta = bli_obj_scalar_buffer( dt_beta, *beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_a][dt_x][dt_y];
// Invoke the function.
f( uplo,
conja,
conjx,
conjh,
m,
buf_alpha,
buf_a, rs_a, cs_a,
buf_x, incx,
buf_beta,
buf_y, incy );
}
void libblis_test_addm_check
(
test_params_t* params,
obj_t* alpha,
obj_t* beta,
obj_t* x,
obj_t* y,
double* resid
)
{
num_t dt = bli_obj_dt( y );
num_t dt_real = bli_obj_dt_proj_to_real( y );
dim_t m = bli_obj_length( y );
dim_t n = bli_obj_width( y );
conj_t conjx = bli_obj_conj_status( x );
obj_t aplusb;
obj_t alpha_conj;
obj_t norm_r, m_r, n_r, temp_r;
double junk;
//
// Pre-conditions:
// - x is set to alpha.
// - y_orig is set to beta.
// Note:
// - alpha and beta should have non-zero imaginary components in the
// complex cases in order to more fully exercise the implementation.
//
// Under these conditions, we assume that the implementation for
//
// y := y_orig + conjx(x)
//
// is functioning correctly if
//
// normfv(y) - sqrt( absqsc( beta + conjx(alpha) ) * m * n )
//
// is negligible.
//
bli_obj_scalar_init_detached( dt, &aplusb );
bli_obj_scalar_init_detached( dt_real, &temp_r );
bli_obj_scalar_init_detached( dt_real, &norm_r );
bli_obj_scalar_init_detached( dt_real, &m_r );
bli_obj_scalar_init_detached( dt_real, &n_r );
bli_obj_scalar_init_detached_copy_of( dt, conjx, alpha, &alpha_conj );
bli_normfm( y, &norm_r );
bli_copysc( beta, &aplusb );
bli_addsc( &alpha_conj, &aplusb );
bli_setsc( ( double )m, 0.0, &m_r );
bli_setsc( ( double )n, 0.0, &n_r );
bli_absqsc( &aplusb, &temp_r );
bli_mulsc( &m_r, &temp_r );
bli_mulsc( &n_r, &temp_r );
bli_sqrtsc( &temp_r, &temp_r );
bli_subsc( &temp_r, &norm_r );
bli_getsc( &norm_r, resid, &junk );
}
void bli_dotxaxpyf_unb_var2( obj_t* alpha,
obj_t* at,
obj_t* a,
obj_t* w,
obj_t* x,
obj_t* beta,
obj_t* y,
obj_t* z )
{
num_t dt_a = bli_obj_datatype( *a );
num_t dt_x = bli_obj_datatype( *x );
num_t dt_y = bli_obj_datatype( *y );
conj_t conjat = bli_obj_conj_status( *at );
conj_t conja = bli_obj_conj_status( *a );
conj_t conjw = bli_obj_conj_status( *w );
conj_t conjx = bli_obj_conj_status( *x );
dim_t m = bli_obj_vector_dim( *z );
dim_t b_n = bli_obj_vector_dim( *y );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
inc_t inc_w = bli_obj_vector_inc( *w );
void* buf_w = bli_obj_buffer_at_off( *w );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_y = bli_obj_vector_inc( *y );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t inc_z = bli_obj_vector_inc( *z );
void* buf_z = bli_obj_buffer_at_off( *z );
num_t dt_alpha;
void* buf_alpha;
num_t dt_beta;
void* buf_beta;
FUNCPTR_T f;
// The datatype of alpha MUST be the type union of a and x. This is to
// prevent any unnecessary loss of information during computation.
dt_alpha = bli_datatype_union( dt_a, dt_x );
buf_alpha = bli_obj_buffer_for_1x1( dt_alpha, *alpha );
// The datatype of beta MUST be the same as the datatype of y.
dt_beta = dt_y;
buf_beta = bli_obj_buffer_for_1x1( dt_beta, *beta );
// Index into the type combination array to extract the correct
// function pointer.
f = ftypes[dt_a][dt_x][dt_y];
// Invoke the function.
f( conjat,
conja,
conjw,
conjx,
m,
b_n,
buf_alpha,
buf_a, rs_a, cs_a,
buf_w, inc_w,
buf_x, inc_x,
buf_beta,
buf_y, inc_y,
buf_z, inc_z );
}
//
// Define object-based interface.
//
void bli_dotxf( obj_t* alpha,
obj_t* a,
obj_t* x,
obj_t* beta,
obj_t* y )
{
num_t dt = bli_obj_datatype( *x );
conj_t conja = bli_obj_conj_status( *a );
conj_t conjx = bli_obj_conj_status( *x );
dim_t m = bli_obj_vector_dim( *y );
dim_t b_n = bli_obj_vector_dim( *x );
void* buf_a = bli_obj_buffer_at_off( *a );
inc_t rs_a = bli_obj_row_stride( *a );
inc_t cs_a = bli_obj_col_stride( *a );
void* buf_x = bli_obj_buffer_at_off( *x );
inc_t inc_x = bli_obj_vector_inc( *x );
void* buf_y = bli_obj_buffer_at_off( *y );
inc_t inc_y = bli_obj_vector_inc( *y );
obj_t alpha_local;
void* buf_alpha;
obj_t beta_local;
void* buf_beta;
FUNCPTR_T f = ftypes[dt];
if ( bli_error_checking_is_enabled() )
bli_dotxf_check( alpha, a, x, beta, y );
// Create local copy-casts of the scalars (and apply internal conjugation
// if needed).
bli_obj_scalar_init_detached_copy_of( dt,
BLIS_NO_CONJUGATE,
alpha,
&alpha_local );
bli_obj_scalar_init_detached_copy_of( dt,
BLIS_NO_CONJUGATE,
beta,
&beta_local );
// Extract the scalar buffers.
buf_alpha = bli_obj_buffer_for_1x1( dt, alpha_local );
buf_beta = bli_obj_buffer_for_1x1( dt, beta_local );
// Support cases where matrix A requires a transposition.
if ( bli_obj_has_trans( *a ) ) { bli_swap_incs( rs_a, cs_a ); }
// Invoke the void pointer-based function.
f( conja,
conjx,
m,
b_n,
buf_alpha,
buf_a, rs_a, cs_a,
buf_x, inc_x,
buf_beta,
buf_y, inc_y );
}
void libblis_test_gemv_check
(
test_params_t* params,
obj_t* kappa,
obj_t* alpha,
obj_t* a,
obj_t* x,
obj_t* beta,
obj_t* y,
obj_t* y_orig,
double* resid
)
{
num_t dt = bli_obj_dt( y );
num_t dt_real = bli_obj_dt_proj_to_real( y );
conj_t conja = bli_obj_conj_status( a );
dim_t n_x = bli_obj_vector_dim( x );
dim_t m_y = bli_obj_vector_dim( y );
dim_t min_m_n = bli_min( m_y, n_x );
obj_t x_temp, y_temp;
obj_t kappac, norm;
obj_t xT_temp, yT_temp, yT;
double junk;
//
// Pre-conditions:
// - a is initialized to kappa along the diagonal.
// - x is randomized.
// - y_orig is randomized.
// Note:
// - alpha, beta, and kappa should have non-zero imaginary components in
// the complex cases in order to more fully exercise the implementation.
//
// Under these conditions, we assume that the implementation for
//
// y := beta * y_orig + alpha * transa(A) * conjx(x)
//
// is functioning correctly if
//
// normf( y - z )
//
// is negligible, where
//
// z = beta * y_orig + alpha * conja(kappa) * x
//
bli_obj_scalar_init_detached_copy_of( dt, conja, kappa, &kappac );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, n_x, 1, 0, 0, &x_temp );
bli_obj_create( dt, m_y, 1, 0, 0, &y_temp );
bli_copyv( x, &x_temp );
bli_copyv( y_orig, &y_temp );
bli_acquire_vpart_f2b( BLIS_SUBPART1, 0, min_m_n,
&x_temp, &xT_temp );
bli_acquire_vpart_f2b( BLIS_SUBPART1, 0, min_m_n,
&y_temp, &yT_temp );
bli_acquire_vpart_f2b( BLIS_SUBPART1, 0, min_m_n,
y, &yT );
bli_scalv( &kappac, &xT_temp );
bli_scalv( beta, &yT_temp );
bli_axpyv( alpha, &xT_temp, &yT_temp );
bli_subv( &yT_temp, &yT );
bli_normfv( &yT, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &x_temp );
bli_obj_free( &y_temp );
}
