void testTiming(Blackbox & A)
{
typedef typename Blackbox::MatrixDomain Dom;
typedef typename Dom::Block Block;
Dom MD = A.domain();
size_t m = A.rowdim(), n = A.coldim();
size_t k = (m + n)/2;
LinBox::UserTimer timer;
Block B(n,k), C(m,k), D(k,m), E(k,n), F(k,k);
MD.random(B); MD.random(D);
vector<typename Dom::Element> v1, v2(m);
typename Dom::RandIter r(MD);
typename Dom::Element x;
for(size_t i = 0; i != n; ++i){
r.random(x);
v1.push_back(x);
}
//Tests:
cout << "Timing tests:" << endl << endl;
timer.clear(); timer.start();
for(size_t j = 0; j != m; ++j) A.apply(v2,v1);
timer.stop();
cout << "apply using vectors time: " << timer << endl;
timer.clear(); timer.start();
A.applyTranspose(C,B);
timer.stop();
cout << "apply using row addin time: " << timer << endl;
timer.clear(); timer.start();
A.unpackingApplyTranspose(C,B);
timer.stop();
cout << "apply using block axpy time: " << timer << endl;
timer.clear(); timer.start();
MD.mul(F, D, C);
timer.stop();
cout << "Matrix Domain mul time: " << timer << endl;
cout << "End of timing tests" << endl << endl;
} // testTiming
static bool testTransposeBlackbox(Blackbox & A)
{
typedef typename Blackbox::Field Field;
commentator().start ("Testing Transpose", "testTranspose", 1);
Transpose<Blackbox> B(A);
bool ret = true, ret1;
size_t m = A.rowdim(), n = A.coldim();
const Field & F = A.field();
VectorDomain<Field> VD (F);
BlasVector<Field> x(F,n), y(F,m), z(F,n), w(F,m);
VD.random(x);
A.apply(y, x);
B.applyTranspose(w, x);
ret1 = VD.areEqual(y, w);
if (not ret1) commentator().report() << "A and B^T disagree, FAIL" << std::endl;
ret = ret and ret1;
VD.random(y);
A.applyTranspose(x, y);
B.apply(z, y);
ret1 = VD.areEqual(x, z);
if (not ret1) commentator().report() << "A^T and B disagree, FAIL" << std::endl;
ret = ret and ret1;
ret1 = testBlackboxNoRW(B);
if (not ret1) commentator().report() << "testBlackbox A^T FAIL" << std::endl;
ret = ret and ret1;
commentator().stop (MSG_STATUS (ret), (const char *) 0, "testTranspose");
return ret;
}
static bool testSingularInconsistentSolve (const Field &F,
VectorStream<Vector> &stream1,
VectorStream<Vector> &stream2,
const char *text,
MethodTraits method)
{
typedef Diagonal <Field, Vector> Blackbox;
ostringstream str;
str << "Testing singular inconsistent solve (" << text << ")";
commentator().start (str.str ().c_str (), "testSingularInconsistentSolve", stream1.m ());
VectorDomain<Field> VD (F);
typename WiedemannSolver<Field>::ReturnStatus status;
bool ret = true;
Vector d1, d, b, x, y, u;
typename Field::Element uTb;
VectorWrapper::ensureDim (d, stream2.dim ());
VectorWrapper::ensureDim (b, stream2.dim ());
VectorWrapper::ensureDim (x, stream2.dim ());
VectorWrapper::ensureDim (y, stream2.dim ());
VectorWrapper::ensureDim (d1, stream1.dim ());
MethodTraits traits (method);
traits.preconditioner (MethodTraits::NONE);
while (stream1 && stream2) {
commentator().startIteration ((unsigned)stream1.j ());
stream1.next (d1);
stream2.next (b);
VD.copy (d, d1);
ostream &report = commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_DESCRIPTION);
report << "Diagonal entries: ";
VD.write (report, d);
report << endl;
report << "Right-hand side: ";
VD.write (report, b);
report << endl;
BlasVector<Field> dd(F,d);
Blackbox D (dd);
//Blackbox D (d);
status = solve (D, x, b, u, F, traits);
if (status == WiedemannSolver<Field>::INCONSISTENT) {
D.applyTranspose (y, u);
report << "Certificate of inconsistency found." << endl;
report << "Certificate is: ";
VD.write (report, u) << endl;
report << "u^T A = ";
VD.write (report, y) << endl;
VD.dot (uTb, u, b);
report << "u^T b = ";
F.write (report, uTb) << endl;
if (!VD.isZero (y)) {
commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR)
<< "ERROR: u is not in the right nullspace of D" << endl;
ret = false;
}
if (F.isZero (uTb)) {
commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR)
<< "ERROR: u^T b = 0" << endl;
ret = false;
}
}
else if (status == WiedemannSolver<Field>::FAILED) {
commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR)
<< "ERROR: Solver refused to certify inconsistency" << endl;
ret = false;
}
else {
commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR)
<< "ERROR: Solver gave solution even though system is inconsistent" << endl;
ret = false;
}
commentator().stop ("done");
commentator().progress ();
}
stream1.reset ();
stream2.reset ();
commentator().stop (MSG_STATUS (ret), (const char *) 0, "testSingularInconsistentSolve");
return ret;
}