void libblis_test_addv_check( obj_t* alpha,
obj_t* beta,
obj_t* x,
obj_t* y,
double* resid )
{
num_t dt = bli_obj_datatype( *x );
num_t dt_real = bli_obj_datatype_proj_to_real( *x );
dim_t m = bli_obj_vector_dim( *x );
conj_t conjx = bli_obj_conj_status( *x );
obj_t aplusb;
obj_t alpha_conj;
obj_t norm_r, m_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
//
// fnormv(y) - sqrt( absqsc( beta + conjx(alpha) ) * m )
//
// 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_copy_of( dt, conjx, alpha, &alpha_conj );
bli_fnormv( y, &norm_r );
bli_copysc( beta, &aplusb );
bli_addsc( &alpha_conj, &aplusb );
bli_setsc( ( double )m, 0.0, &m_r );
bli_absqsc( &aplusb, &temp_r );
bli_mulsc( &m_r, &temp_r );
bli_sqrtsc( &temp_r, &temp_r );
bli_subsc( &temp_r, &norm_r );
bli_getsc( &norm_r, resid, &junk );
}
void libblis_test_axpyv_check( obj_t* alpha,
obj_t* x,
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 m = bli_obj_vector_dim( *y );
obj_t x_temp, y_temp;
obj_t norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - y_orig is randomized.
// Note:
// - alpha 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 := y_orig + alpha * conjx(x)
//
// is functioning correctly if
//
// fnorm( y - ( y_orig + alpha * conjx(x) ) )
//
// is negligible.
//
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m, 1, 0, 0, &x_temp );
bli_obj_create( dt, m, 1, 0, 0, &y_temp );
bli_copyv( x, &x_temp );
bli_copyv( y_orig, &y_temp );
bli_scalv( alpha, &x_temp );
bli_addv( &x_temp, &y_temp );
bli_subv( &y_temp, y );
bli_fnormv( y, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &x_temp );
bli_obj_free( &y_temp );
}
void libblis_test_fnormv_impl( mt_impl_t impl,
obj_t* x,
obj_t* norm )
{
switch ( impl )
{
case BLIS_TEST_SEQ_FRONT_END:
bli_fnormv( x, norm );
break;
default:
libblis_test_printf_error( "Invalid implementation type.\n" );
}
}
void libblis_test_trmv_check( obj_t* alpha,
obj_t* a,
obj_t* x,
obj_t* x_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *x );
num_t dt_real = bli_obj_datatype_proj_to_real( *x );
dim_t m = bli_obj_vector_dim( *x );
uplo_t uploa = bli_obj_uplo( *a );
trans_t transa = bli_obj_conjtrans_status( *a );
obj_t a_local, y;
obj_t norm;
double junk;
//
// Pre-conditions:
// - a is randomized and triangular.
// - x is randomized.
// Note:
// - alpha 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
//
// x := alpha * transa(A) * x_orig
//
// is functioning correctly if
//
// fnorm( y - x )
//
// is negligible, where
//
// y = alpha * conja(A_dense) * x_orig
//
bli_obj_init_scalar( dt_real, &norm );
bli_obj_create( dt, m, 1, 0, 0, &y );
bli_obj_create( dt, m, m, 0, 0, &a_local );
bli_obj_set_struc( BLIS_TRIANGULAR, a_local );
bli_obj_set_uplo( uploa, a_local );
bli_obj_toggle_uplo_if_trans( transa, a_local );
bli_copym( a, &a_local );
bli_mktrim( &a_local );
bli_obj_set_struc( BLIS_GENERAL, a_local );
bli_obj_set_uplo( BLIS_DENSE, a_local );
bli_gemv( alpha, &a_local, x_orig, &BLIS_ZERO, &y );
bli_subv( x, &y );
bli_fnormv( &y, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &y );
bli_obj_free( &a_local );
}
void libblis_test_gemmtrsm_ukr_check( side_t side,
obj_t* alpha,
obj_t* a1x,
obj_t* a11,
obj_t* bx1,
obj_t* b11,
obj_t* c11,
obj_t* c11_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *b11 );
num_t dt_real = bli_obj_datatype_proj_to_real( *b11 );
dim_t m = bli_obj_length( *b11 );
dim_t n = bli_obj_width( *b11 );
dim_t k = bli_obj_width( *a1x );
obj_t kappa, norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a1x, a11, bx1, c11_orig are randomized; a11 is triangular.
// - contents of b11 == contents of c11.
// - side == BLIS_LEFT.
//
// Under these conditions, we assume that the implementation for
//
// B := inv(A11) * ( alpha * B11 - A1x * Bx1 ) (side = left)
//
// is functioning correctly if
//
// fnorm( v - z )
//
// is negligible, where
//
// v = B11 * t
//
// z = ( inv(A11) * ( alpha * B11_orig - A1x * Bx1 ) ) * t
// = inv(A11) * ( alpha * B11_orig * t - A1x * Bx1 * t )
// = inv(A11) * ( alpha * B11_orig * t - A1x * w )
//
bli_obj_scalar_init_detached( dt, &kappa );
bli_obj_scalar_init_detached( dt_real, &norm );
if ( bli_is_left( side ) )
{
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
}
else // else if ( bli_is_left( side ) )
{
// BLIS does not currently support right-side micro-kernels.
bli_check_error_code( BLIS_NOT_YET_IMPLEMENTED );
}
bli_randv( &t );
bli_setsc( 1.0/( double )n, 0.0, &kappa );
bli_scalv( &kappa, &t );
bli_gemv( &BLIS_ONE, b11, &t, &BLIS_ZERO, &v );
// Restore the diagonal of a11 to its original, un-inverted state
// (needed for trsv).
bli_invertd( a11 );
if ( bli_is_left( side ) )
{
bli_gemv( &BLIS_ONE, bx1, &t, &BLIS_ZERO, &w );
bli_gemv( alpha, c11_orig, &t, &BLIS_ZERO, &z );
bli_gemv( &BLIS_MINUS_ONE, a1x, &w, &BLIS_ONE, &z );
bli_trsv( &BLIS_ONE, a11, &z );
}
else // else if ( bli_is_left( side ) )
{
// BLIS does not currently support right-side micro-kernels.
bli_check_error_code( BLIS_NOT_YET_IMPLEMENTED );
}
bli_subv( &z, &v );
bli_fnormv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_syr_check( obj_t* alpha,
obj_t* x,
obj_t* a,
obj_t* a_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *a );
num_t dt_real = bli_obj_datatype_proj_to_real( *a );
dim_t m_a = bli_obj_length( *a );
obj_t xt, t, v, w;
obj_t tau, rho, norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - a is randomized and symmetric.
// Note:
// - alpha 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
//
// A := A_orig + alpha * conjx(x) * conjx(x)^T
//
// is functioning correctly if
//
// fnorm( v - w )
//
// is negligible, where
//
// v = A * t
// w = ( A_orig + alpha * conjx(x) * conjx(x)^T ) * t
// = A_orig * t + alpha * conjx(x) * conjx(x)^T * t
// = A_orig * t + alpha * conjx(x) * rho
// = A_orig * t + w
//
bli_mksymm( a );
bli_mksymm( a_orig );
bli_obj_set_struc( BLIS_GENERAL, *a );
bli_obj_set_struc( BLIS_GENERAL, *a_orig );
bli_obj_set_uplo( BLIS_DENSE, *a );
bli_obj_set_uplo( BLIS_DENSE, *a_orig );
bli_obj_init_scalar( dt, &tau );
bli_obj_init_scalar( dt, &rho );
bli_obj_init_scalar( dt_real, &norm );
bli_obj_create( dt, m_a, 1, 0, 0, &t );
bli_obj_create( dt, m_a, 1, 0, 0, &v );
bli_obj_create( dt, m_a, 1, 0, 0, &w );
bli_obj_alias_to( *x, xt );
bli_setsc( 1.0/( double )m_a, -1.0/( double )m_a, &tau );
bli_setv( &tau, &t );
bli_gemv( &BLIS_ONE, a, &t, &BLIS_ZERO, &v );
bli_dotv( &xt, &t, &rho );
bli_mulsc( alpha, &rho );
bli_scal2v( &rho, x, &w );
bli_gemv( &BLIS_ONE, a_orig, &t, &BLIS_ONE, &w );
bli_subv( &w, &v );
bli_fnormv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
}
void libblis_test_trmm3_check( side_t side,
obj_t* alpha,
obj_t* a,
obj_t* b,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *c );
num_t dt_real = bli_obj_datatype_proj_to_real( *c );
dim_t m = bli_obj_length( *c );
dim_t n = bli_obj_width( *c );
obj_t kappa, norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a is randomized and triangular.
// - b is randomized.
// - c_orig is randomized.
// 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
//
// C := beta * C_orig + alpha * transa(A) * transb(B) (side = left)
// C := beta * C_orig + alpha * transb(B) * transa(A) (side = right)
//
// is functioning correctly if
//
// fnorm( v - z )
//
// is negligible, where
//
// v = C * t
//
// z = ( beta * C_orig + alpha * transa(A) * transb(B) ) * t (side = left)
// = beta * C_orig * t + alpha * transa(A) * transb(B) * t
// = beta * C_orig * t + alpha * transa(A) * w
// = beta * C_orig * t + z
//
// z = ( beta * C_orig + alpha * transb(B) * transa(A) ) * t (side = right)
// = beta * C_orig * t + alpha * transb(B) * transa(A) * t
// = beta * C_orig * t + alpha * transb(B) * w
// = beta * C_orig * t + z
bli_obj_scalar_init_detached( dt, &kappa );
bli_obj_scalar_init_detached( dt_real, &norm );
if ( bli_is_left( side ) )
{
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, m, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
}
else // else if ( bli_is_left( side ) )
{
bli_obj_create( dt, n, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, n, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
}
bli_randv( &t );
bli_setsc( 1.0/( double )n, 0.0, &kappa );
bli_scalv( &kappa, &t );
bli_gemv( &BLIS_ONE, c, &t, &BLIS_ZERO, &v );
if ( bli_is_left( side ) )
{
bli_gemv( &BLIS_ONE, b, &t, &BLIS_ZERO, &w );
bli_trmv( alpha, a, &w );
bli_copyv( &w, &z );
}
else
{
bli_copyv( &t, &w );
bli_trmv( &BLIS_ONE, a, &w );
bli_gemv( alpha, b, &w, &BLIS_ZERO, &z );
}
bli_gemv( beta, c_orig, &t, &BLIS_ONE, &z );
bli_subv( &z, &v );
bli_fnormv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_syrk_check( obj_t* alpha,
obj_t* a,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *c );
num_t dt_real = bli_obj_datatype_proj_to_real( *c );
dim_t m = bli_obj_length( *c );
dim_t k = bli_obj_width_after_trans( *a );
obj_t at;
obj_t kappa, norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - c_orig is randomized and symmetric.
// 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
//
// C := beta * C_orig + alpha * transa(A) * transa(A)^T
//
// is functioning correctly if
//
// fnorm( v - z )
//
// is negligible, where
//
// v = C * t
// z = ( beta * C_orig + alpha * transa(A) * transa(A)^T ) * t
// = beta * C_orig * t + alpha * transa(A) * transa(A)^T * t
// = beta * C_orig * t + alpha * transa(A) * w
// = beta * C_orig * t + z
//
bli_obj_alias_with_trans( BLIS_TRANSPOSE, *a, at );
bli_obj_scalar_init_detached( dt, &kappa );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
bli_randv( &t );
bli_setsc( 1.0/( double )m, 0.0, &kappa );
bli_scalv( &kappa, &t );
bli_symv( &BLIS_ONE, c, &t, &BLIS_ZERO, &v );
bli_gemv( &BLIS_ONE, &at, &t, &BLIS_ZERO, &w );
bli_gemv( alpha, a, &w, &BLIS_ZERO, &z );
bli_symv( beta, c_orig, &t, &BLIS_ONE, &z );
bli_subv( &z, &v );
bli_fnormv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_gemv_check( 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_datatype( *y );
num_t dt_real = bli_obj_datatype_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
//
// fnorm( y - z )
//
// is negligible, where
//
// z = beta * y_orig + alpha * conja(kappa) * x
//
bli_obj_init_scalar_copy_of( dt, conja, kappa, &kappac );
bli_obj_init_scalar( 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_fnormv( &yT, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &x_temp );
bli_obj_free( &y_temp );
}
void libblis_test_her2_check( obj_t* alpha,
obj_t* x,
obj_t* y,
obj_t* a,
obj_t* a_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *a );
num_t dt_real = bli_obj_datatype_proj_to_real( *a );
dim_t m_a = bli_obj_length( *a );
obj_t xh, yh, alphac;
obj_t t, v, w1, w2;
obj_t tau, rho, norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - y is randomized.
// - a is randomized and Hermitian.
//
// Under these conditions, we assume that the implementation for
//
// A := A_orig + alpha * conjx(x) * conjy(y)^H + conj(alpha) * conjy(y) * conjx(x)^H
//
// is functioning correctly if
//
// fnorm( v - w )
//
// is negligible, where
//
// v = A * t
// w = ( A_orig + alpha * conjx(x) * conjy(y)^H + conj(alpha) * conjy(y) * conjx(x)^H ) * t
// = A_orig * t + alpha * conjx(x) * conjy(y)^H * t + conj(alpha) * conjy(y) * conjx(x)^H * t
// = A_orig * t + alpha * conjx(x) * conjy(y)^H * t + conj(alpha) * conjy(y) * rho
// = A_orig * t + alpha * conjx(x) * conjy(y)^H * t + w1
// = A_orig * t + alpha * conjx(x) * rho + w1
// = A_orig * t + w2 + w1
//
bli_mkherm( a );
bli_mkherm( a_orig );
bli_obj_set_struc( BLIS_GENERAL, *a );
bli_obj_set_struc( BLIS_GENERAL, *a_orig );
bli_obj_set_uplo( BLIS_DENSE, *a );
bli_obj_set_uplo( BLIS_DENSE, *a_orig );
bli_obj_scalar_init_detached( dt, &tau );
bli_obj_scalar_init_detached( dt, &rho );
bli_obj_scalar_init_detached( dt, &alphac );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m_a, 1, 0, 0, &t );
bli_obj_create( dt, m_a, 1, 0, 0, &v );
bli_obj_create( dt, m_a, 1, 0, 0, &w1 );
bli_obj_create( dt, m_a, 1, 0, 0, &w2 );
bli_obj_alias_with_conj( BLIS_CONJUGATE, *x, xh );
bli_obj_alias_with_conj( BLIS_CONJUGATE, *y, yh );
bli_obj_alias_with_conj( BLIS_CONJUGATE, *alpha, alphac );
bli_setsc( 1.0/( double )m_a, -1.0/( double )m_a, &tau );
bli_setv( &tau, &t );
bli_gemv( &BLIS_ONE, a, &t, &BLIS_ZERO, &v );
bli_dotv( &xh, &t, &rho );
bli_mulsc( &alphac, &rho );
bli_scal2v( &rho, y, &w1 );
bli_dotv( &yh, &t, &rho );
bli_mulsc( alpha, &rho );
bli_scal2v( &rho, x, &w2 );
bli_addv( &w2, &w1 );
bli_gemv( &BLIS_ONE, a_orig, &t, &BLIS_ONE, &w1 );
bli_subv( &w1, &v );
bli_fnormv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w1 );
bli_obj_free( &w2 );
}
void libblis_test_herk_check( obj_t* alpha,
obj_t* a,
obj_t* beta,
obj_t* c,
obj_t* c_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *c );
num_t dt_real = bli_obj_datatype_proj_to_real( *c );
dim_t m = bli_obj_length( *c );
dim_t k = bli_obj_width_after_trans( *a );
obj_t ah;
obj_t kappa, norm;
obj_t t, v, w, z;
double junk;
//
// Pre-conditions:
// - a is randomized.
// - c_orig is randomized and Hermitian.
// Note:
// - alpha and beta must be real-valued.
//
// Under these conditions, we assume that the implementation for
//
// C := beta * C_orig + alpha * transa(A) * transa(A)^H
//
// is functioning correctly if
//
// fnorm( v - z )
//
// is negligible, where
//
// v = C * t
// z = ( beta * C_orig + alpha * transa(A) * transa(A)^H ) * t
// = beta * C_orig * t + alpha * transa(A) * transa(A)^H * t
// = beta * C_orig * t + alpha * transa(A) * w
// = beta * C_orig * t + z
//
bli_obj_alias_with_trans( BLIS_CONJ_TRANSPOSE, *a, ah );
bli_obj_scalar_init_detached( dt, &kappa );
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m, 1, 0, 0, &t );
bli_obj_create( dt, m, 1, 0, 0, &v );
bli_obj_create( dt, k, 1, 0, 0, &w );
bli_obj_create( dt, m, 1, 0, 0, &z );
bli_randv( &t );
bli_setsc( 1.0/( double )m, 0.0, &kappa );
bli_scalv( &kappa, &t );
bli_hemv( &BLIS_ONE, c, &t, &BLIS_ZERO, &v );
bli_gemv( &BLIS_ONE, &ah, &t, &BLIS_ZERO, &w );
bli_gemv( alpha, a, &w, &BLIS_ZERO, &z );
bli_hemv( beta, c_orig, &t, &BLIS_ONE, &z );
bli_subv( &z, &v );
bli_fnormv( &v, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &t );
bli_obj_free( &v );
bli_obj_free( &w );
bli_obj_free( &z );
}
void libblis_test_axpy2v_check( obj_t* alpha1,
obj_t* alpha2,
obj_t* x,
obj_t* y,
obj_t* z,
obj_t* z_orig,
double* resid )
{
num_t dt = bli_obj_datatype( *z );
num_t dt_real = bli_obj_datatype_proj_to_real( *z );
dim_t m = bli_obj_vector_dim( *z );
obj_t x_temp, y_temp, z_temp;
obj_t norm;
double junk;
//
// Pre-conditions:
// - x is randomized.
// - y is randomized.
// - z_orig is randomized.
// Note:
// - alpha1, alpha2 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
//
// z := z_orig + alpha1 * conjx(x) + alpha2 * conjy(y)
//
// is functioning correctly if
//
// fnorm( z - v )
//
// is negligible, where v contains z as computed by two calls to axpyv.
//
bli_obj_scalar_init_detached( dt_real, &norm );
bli_obj_create( dt, m, 1, 0, 0, &x_temp );
bli_obj_create( dt, m, 1, 0, 0, &y_temp );
bli_obj_create( dt, m, 1, 0, 0, &z_temp );
bli_copyv( x, &x_temp );
bli_copyv( y, &y_temp );
bli_copyv( z_orig, &z_temp );
bli_scalv( alpha1, &x_temp );
bli_scalv( alpha2, &y_temp );
bli_addv( &x_temp, &z_temp );
bli_addv( &y_temp, &z_temp );
bli_subv( &z_temp, z );
bli_fnormv( z, &norm );
bli_getsc( &norm, resid, &junk );
bli_obj_free( &x_temp );
bli_obj_free( &y_temp );
bli_obj_free( &z_temp );
}
