void LinAlgOpPack::V_InvMtV(
DVectorSlice* y, const MatrixOpNonsing& M
,BLAS_Cpp::Transp M_trans, const SpVectorSlice& x
)
{
using BLAS_Cpp::trans;
using AbstractLinAlgPack::VectorDenseMutableEncap;
VectorSpace::vec_mut_ptr_t
ay = ( M_trans == trans ? M.space_cols() : M.space_rows() ).create_member();
AbstractLinAlgPack::V_InvMtV( ay.get(), M, M_trans, x );
*y = VectorDenseMutableEncap(*ay)();
}
void ExampleBasisSystem::update_D(
const MatrixOpNonsing &C
,const MatrixOp &N
,MatrixOp *D
,EMatRelations mat_rel
) const
{
using Teuchos::dyn_cast;
TEUCHOS_TEST_FOR_EXCEPTION(
D == NULL, std::logic_error
,"ExampleBasisSystem::update_D(...): Error!" );
const MatrixSymDiagStd
&C_aggr = dyn_cast<const MatrixSymDiagStd>(C),
&N_aggr = dyn_cast<const MatrixSymDiagStd>(N);
MatrixSymDiagStd
&D_sym_diag = dyn_cast<MatrixSymDiagStd>(*D);
if( D_sym_diag.rows() != C.rows() )
D_sym_diag.initialize(
this->space_x()->sub_space(this->var_dep())->create_member()
);
AbstractLinAlgPack::ele_wise_divide( // D_diag = - N_diag ./ C_diag
-1.0, N_aggr.diag(), C_aggr.diag(), &D_sym_diag.diag() ); // ...
}
void LinAlgOpPack::V_InvMtV(
DVector* y, const MatrixOpNonsing& M
,BLAS_Cpp::Transp M_trans, const SpVectorSlice& x
)
{
y->resize(M.rows());
LinAlgOpPack::V_InvMtV( &(*y)(), M, M_trans, x );
}
bool MatrixOpNonsingTester::test_matrix(
const MatrixOpNonsing &M
,const char M_name[]
,std::ostream *out
)
{
namespace rcp = MemMngPack;
using BLAS_Cpp::no_trans;
using BLAS_Cpp::trans;
using BLAS_Cpp::left;
using BLAS_Cpp::right;
using AbstractLinAlgPack::sum;
using AbstractLinAlgPack::dot;
using AbstractLinAlgPack::Vp_StV;
using AbstractLinAlgPack::assert_print_nan_inf;
using AbstractLinAlgPack::random_vector;
using LinAlgOpPack::V_StMtV;
using LinAlgOpPack::V_MtV;
using LinAlgOpPack::V_StV;
using LinAlgOpPack::V_VpV;
using LinAlgOpPack::Vp_V;
// ToDo: Check the preconditions
bool success = true, result, lresult;
const value_type
rand_y_l = -1.0,
rand_y_u = 1.0,
small_num = ::pow(std::numeric_limits<value_type>::epsilon(),0.25),
alpha = 2.0;
//
// Perform the tests
//
if(out && print_tests() >= PRINT_BASIC)
*out
<< "\nCheck: alpha*op(op(inv("<<M_name<<"))*op("<<M_name<<"))*v == alpha*v ...";
if(out && print_tests() > PRINT_BASIC)
*out << std::endl;
VectorSpace::vec_mut_ptr_t
v_c1 = M.space_cols().create_member(),
v_c2 = M.space_cols().create_member(),
v_r1 = M.space_rows().create_member(),
v_r2 = M.space_rows().create_member();
// Side of the matrix inverse
const BLAS_Cpp::Side a_side[2] = { BLAS_Cpp::left, BLAS_Cpp::right };
// If the matrices are transposed or not
const BLAS_Cpp::Transp a_trans[2] = { BLAS_Cpp::no_trans, BLAS_Cpp::trans };
for( int side_i = 0; side_i < 2; ++side_i ) {
for( int trans_i = 0; trans_i < 2; ++trans_i ) {
const BLAS_Cpp::Side t_side = a_side[side_i];
const BLAS_Cpp::Transp t_trans = a_trans[trans_i];
if(out && print_tests() >= PRINT_MORE)
*out
<< "\n" << side_i+1 << "." << trans_i+1 << ") "
<< "Check: (t2 = "<<(t_side==left?"inv(":"alpha * ")<< M_name<<(t_trans==trans?"\'":"")<<(t_side==left?")":"")
<< " * (t1 = "<<(t_side==right?"inv(":"alpha * ")<<M_name<<(t_trans==trans?"\'":"")<<(t_side==right?")":"")
<< " * v)) == alpha * v ...";
if(out && print_tests() > PRINT_MORE)
*out << std::endl;
result = true;
VectorMutable
*v = NULL,
*t1 = NULL,
*t2 = NULL;
if( (t_side == left && t_trans == no_trans) || (t_side == right && t_trans == trans) ) {
// (inv(R)*R*v or R'*inv(R')*v
v = v_r1.get();
t1 = v_c1.get();
t2 = v_r2.get();
}
else {
// (inv(R')*R'*v or R*inv(R)*v
v = v_c1.get();
t1 = v_r1.get();
t2 = v_c2.get();
}
for( int k = 1; k <= num_random_tests(); ++k ) {
lresult = true;
random_vector( rand_y_l, rand_y_u, v );
if(out && print_tests() >= PRINT_ALL) {
*out
<< "\n"<<side_i+1<<"."<<trans_i+1<<"."<<k<<") random vector " << k
<< " ( ||v||_1 / n = " << (v->norm_1() / v->dim()) << " )\n";
if(dump_all() && print_tests() >= PRINT_ALL)
*out << "\nv =\n" << *v;
}
// t1
if( t_side == right ) {
// t1 = inv(op(M))*v
V_InvMtV( t1, M, t_trans, *v );
}
else {
// t1 = alpha*op(M)*v
V_StMtV( t1, alpha, M, t_trans, *v );
}
// t2
if( t_side == left ) {
// t2 = inv(op(M))*t1
V_InvMtV( t2, M, t_trans, *t1 );
}
else {
// t2 = alpha*op(M)*t1
V_StMtV( t2, alpha, M, t_trans, *t1 );
}
const value_type
sum_t2 = sum(*t2),
sum_av = alpha*sum(*v);
assert_print_nan_inf(sum_t2, "sum(t2)",true,out);
assert_print_nan_inf(sum_av, "sum(alpha*t1)",true,out);
const value_type
calc_err = ::fabs( ( sum_av - sum_t2 )
/( ::fabs(sum_av) + ::fabs(sum_t2) + small_num ) );
if(out && print_tests() >= PRINT_ALL)
*out
<< "\nrel_err(sum(alpha*v),sum(t2)) = "
<< "rel_err(" << sum_av << "," << sum_t2 << ") = "
<< calc_err << std::endl;
if( calc_err >= warning_tol() ) {
if(out && print_tests() >= PRINT_ALL)
*out
<< std::endl
<< ( calc_err >= error_tol() ? "Error" : "Warning" )
<< ", rel_err(sum(alpha*v),sum(t2)) = "
<< "rel_err(" << sum_av << "," << sum_t2 << ") = "
<< calc_err
<< " exceeded "
<< ( calc_err >= error_tol() ? "error_tol" : "warning_tol" )
<< " = "
<< ( calc_err >= error_tol() ? error_tol() : warning_tol() )
<< std::endl;
if(calc_err >= error_tol()) {
if(dump_all() && print_tests() >= PRINT_ALL) {
*out << "\nalpha = " << alpha << std::endl;
*out << "\nv =\n" << *v;
*out << "\nt1 =\n" << *t2;
*out << "\nt2 =\n" << *t2;
}
lresult = false;
}
}
if(!lresult) result = false;
}
if(!result) success = false;
if( out && print_tests() == PRINT_MORE )
*out << " : " << ( result ? "passed" : "failed" )
<< std::endl;
}
}
if( out && print_tests() == PRINT_BASIC )
*out << " : " << ( success ? "passed" : "failed" );
return success;
}
