void libblis_test_dotxaxpyf_check
(
test_params_t* params,
obj_t* alpha,
obj_t* at,
obj_t* a,
obj_t* w,
obj_t* x,
obj_t* beta,
obj_t* y,
obj_t* z,
obj_t* y_orig,
obj_t* z_orig,
double* resid
)
{
num_t dt = bli_obj_datatype( *y );
num_t dt_real = bli_obj_datatype_proj_to_real( *y );
dim_t m = bli_obj_vector_dim( *z );
dim_t b_n = bli_obj_vector_dim( *y );
dim_t i;
obj_t a1, chi1, psi1, v, q;
obj_t alpha_chi1;
obj_t norm;
double resid1, resid2;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - w is randomized.
// - x is randomized.
// - y is randomized.
// - z is randomized.
// - at is an alias to a.
// Note:
// - alpha and beta should have a non-zero imaginary component 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 * conjat(A^T) * conjw(w)
// z := z_orig + alpha * conja(A) * conjx(x)
//
// is functioning correctly if
//
// normf( y - v )
//
// and
//
// normf( z - q )
//
// are negligible, where v and q contain y and z as computed by repeated
// calls to dotxv and axpyv, respectively.
//
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_scalar_init_detached( dt, &alpha_chi1 );
bli_obj_create( dt, b_n, 1, 0, 0, &v );
bli_obj_create( dt, m, 1, 0, 0, &q );
bli_copyv( y_orig, &v );
bli_copyv( z_orig, &q );
// v := beta * v + alpha * conjat(at) * conjw(w)
for ( i = 0; i < b_n; ++i )
{
bli_acquire_mpart_l2r( BLIS_SUBPART1, i, 1, at, &a1 );
bli_acquire_vpart_f2b( BLIS_SUBPART1, i, 1, &v, &psi1 );
bli_dotxv( alpha, &a1, w, beta, &psi1 );
}
// q := q + alpha * conja(a) * conjx(x)
for ( i = 0; i < b_n; ++i )
{
bli_acquire_mpart_l2r( BLIS_SUBPART1, i, 1, a, &a1 );
bli_acquire_vpart_f2b( BLIS_SUBPART1, i, 1, x, &chi1 );
bli_copysc( &chi1, &alpha_chi1 );
bli_mulsc( alpha, &alpha_chi1 );
bli_axpyv( &alpha_chi1, &a1, &q );
}
bli_subv( y, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, &resid1, &junk );
bli_subv( z, &q );
bli_normfv( &q, &norm );
bli_getsc( &norm, &resid2, &junk );
*resid = bli_fmaxabs( resid1, resid2 );
bli_obj_free( &v );
bli_obj_free( &q );
}
int main( int argc, char** argv )
{
obj_t alpha, beta, gamma;
obj_t x, y, z, w, a;
num_t dt;
dim_t m, n;
inc_t rs, cs;
//
// This file demonstrates working with vector objects and the level-1v
// operations.
//
//
// Example 1: Create vector objects and then broadcast (copy) scalar
// values to all elements.
//
printf( "\n#\n# -- Example 1 --\n#\n\n" );
// Create a few vectors to work with. We make them all of the same length
// so that we can perform operations between them.
// NOTE: We've chosen to use row vectors here (1x4) instead of column
// vectors (4x1) to allow for easier reading of standard output (less
// scrolling).
dt = BLIS_DOUBLE;
m = 1; n = 4; rs = 0; cs = 0;
bli_obj_create( dt, m, n, rs, cs, &x );
bli_obj_create( dt, m, n, rs, cs, &y );
bli_obj_create( dt, m, n, rs, cs, &z );
bli_obj_create( dt, m, n, rs, cs, &w );
bli_obj_create( dt, m, n, rs, cs, &a );
// Let's also create and initialize some scalar objects.
bli_obj_create_1x1( dt, &alpha );
bli_obj_create_1x1( dt, &beta );
bli_obj_create_1x1( dt, &gamma );
bli_setsc( 2.0, 0.0, &alpha );
bli_setsc( 0.2, 0.0, &beta );
bli_setsc( 3.0, 0.0, &gamma );
bli_printm( "alpha:", &alpha, "%4.1f", "" );
bli_printm( "beta:", &beta, "%4.1f", "" );
bli_printm( "gamma:", &gamma, "%4.1f", "" );
// Vectors can set by "broadcasting" a constant to every element.
bli_setv( &BLIS_ONE, &x );
bli_setv( &alpha, &y );
bli_setv( &BLIS_ZERO, &z );
// Note that we can use printv or printm to print vectors since vectors
// are also matrices. We choose to use printm because it honors the
// orientation of the vector (row or column) when printing, whereas
// printv always prints vectors as column vectors regardless of their
// they are 1 x n or n x 1.
bli_printm( "x := 1.0", &x, "%4.1f", "" );
bli_printm( "y := alpha", &y, "%4.1f", "" );
bli_printm( "z := 0.0", &z, "%4.1f", "" );
//
// Example 2: Randomize a vector object.
//
printf( "\n#\n# -- Example 2 --\n#\n\n" );
// Set a vector to random values.
bli_randv( &w );
bli_printm( "w := randv()", &w, "%4.1f", "" );
//
// Example 3: Perform various element-wise operations on vector objects.
//
printf( "\n#\n# -- Example 3 --\n#\n\n" );
// Copy a vector.
bli_copyv( &w, &a );
bli_printm( "a := w", &a, "%4.1f", "" );
// Add and subtract vectors.
bli_addv( &y, &a );
bli_printm( "a := a + y", &a, "%4.1f", "" );
bli_subv( &w, &a );
bli_printm( "a := a - w", &a, "%4.1f", "" );
// Scale a vector (destructive).
bli_scalv( &beta, &a );
bli_printm( "a := beta * a", &a, "%4.1f", "" );
// Scale a vector (non-destructive).
bli_scal2v( &gamma, &a, &z );
bli_printm( "z := gamma * a", &z, "%4.1f", "" );
// Scale and accumulate between vectors.
bli_axpyv( &alpha, &w, &x );
bli_printm( "x := x + alpha * w", &x, "%4.1f", "" );
bli_xpbyv( &w, &BLIS_MINUS_ONE, &x );
bli_printm( "x := -1.0 * x + w", &x, "%4.1f", "" );
// Invert a vector element-wise.
bli_invertv( &y );
bli_printm( "y := 1 / y", &y, "%4.1f", "" );
// Swap two vectors.
bli_swapv( &x, &y );
bli_printm( "x (after swapping with y)", &x, "%4.1f", "" );
bli_printm( "y (after swapping with x)", &y, "%4.1f", "" );
//
// Example 4: Perform contraction-like operations on vector objects.
//
printf( "\n#\n# -- Example 4 --\n#\n\n" );
// Perform a dot product.
bli_dotv( &a, &z, &gamma );
bli_printm( "gamma := a * z (dot product)", &gamma, "%5.2f", "" );
// Perform an extended dot product.
bli_dotxv( &alpha, &a, &z, &BLIS_ONE, &gamma );
bli_printm( "gamma := 1.0 * gamma + alpha * a * z (accumulate scaled dot product)", &gamma, "%5.2f", "" );
// Free the objects.
bli_obj_free( &alpha );
bli_obj_free( &beta );
bli_obj_free( &gamma );
bli_obj_free( &x );
bli_obj_free( &y );
bli_obj_free( &z );
bli_obj_free( &w );
bli_obj_free( &a );
return 0;
}
void libblis_test_dotxf_check( 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_datatype( *y );
num_t dt_real = bli_obj_datatype_proj_to_real( *y );
dim_t b_n = bli_obj_vector_dim( *y );
dim_t i;
obj_t a1, psi1, v;
obj_t norm;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - x is randomized.
// - y is randomized.
// Note:
// - alpha and beta should have a non-zero imaginary component 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 * conjat(A^T) * conjx(x)
//
// is functioning correctly if
//
// normf( y - v )
//
// is negligible, where v contains y as computed by repeated calls to
// dotxv.
//
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, b_n, 1, 0, 0, &v );
bli_copyv( y_orig, &v );
for ( i = 0; i < b_n; ++i )
{
bli_acquire_mpart_l2r( BLIS_SUBPART1, i, 1, a, &a1 );
bli_acquire_vpart_f2b( BLIS_SUBPART1, i, 1, &v, &psi1 );
bli_dotxv( alpha, &a1, x, beta, &psi1 );
}
bli_subv( y, &v );
bli_normfv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &v );
}
