static bool testSingularPreconditionedSolve (const Field &F,
VectorStream<SparseVector> &stream1,
VectorStream<Vector> &stream2,
const char *text,
Method::Wiedemann::Preconditioner preconditioner)
{
ostringstream str;
str << "Testing singular preconditioned solve (" << text << ")";
commentator().start (str.str ().c_str (), "testSingularPreconditionedSolve", stream1.m ());
VectorDomain<Field> VD (F);
typename WiedemannSolver<Field>::ReturnStatus status;
bool ret = true;
SparseVector d1;
typename Field::Element uTb;
typename LinBox::Vector<Field>::Dense d;
Vector b, x, y, u;
VectorWrapper::ensureDim (d, stream2.dim ());
VectorWrapper::ensureDim (b, stream2.dim ());
VectorWrapper::ensureDim (x, stream2.dim ());
VectorWrapper::ensureDim (y, stream2.dim ());
Method::Wiedemann traits;
traits.preconditioner (preconditioner);
while (stream1 && stream2) {
commentator().startIteration ((unsigned)stream1.j ());
stream1.next (d1);
stream2.next (b);
VD.copy (d, d1);
ostream &report = commentator().report (Commentator::LEVEL_UNIMPORTANT, 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);
Diagonal<Field> A (dd);
//Diagonal<Field> A (F, d);
status = solve (A, x, b, u, F, traits);
if (status == WiedemannSolver<Field>::INCONSISTENT) {
A.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, "testSingularPreconditionedSolve");
return ret;
}
static bool testSingularConsistentSolve (const Field &F,
unsigned int n,
VectorStream<Vector> &stream1,
VectorStream<Vector> &stream2,
const char *text,
MethodTraits method)
{
typedef Diagonal <Field, Vector> Blackbox;
ostringstream str;
str << "Testing singular consistent solve (" << text << ")";
commentator().start (str.str ().c_str (), "testSingularConsistentSolve", stream1.m ());
VectorDomain<Field> VD (F);
bool ret = true;
Vector d1, b1, d, b, x, y;
VectorWrapper::ensureDim (d, n);
VectorWrapper::ensureDim (b, n);
VectorWrapper::ensureDim (x, n);
VectorWrapper::ensureDim (y, n);
VectorWrapper::ensureDim (d1, n);
VectorWrapper::ensureDim (b1, n);
MethodTraits traits (method);
traits.preconditioner (MethodTraits::NO_PRECONDITIONER);
while (stream1 && stream2) {
commentator().startIteration ((unsigned)stream1.j ());
ActivityState state = commentator().saveActivityState ();
stream1.next (d1);
stream2.next (b1);
VD.copy (d, d1);
VD.copy (b, b1);
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);
try {
bool iter_passed = true;
solve (D, x, b, F, traits);
report << "System solution: ";
VD.write (report, x);
report << endl;
D.apply (y, x);
report << "Output: ";
VD.write (report, y);
report << endl;
if (!VD.areEqual (y, b))
ret = iter_passed = false;
if (!iter_passed)
commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR)
<< "ERROR: Computed solution is incorrect" << endl;
}
catch (SolveFailed) {
commentator().restoreActivityState (state);
commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR)
<< "ERROR: System solution failed" << endl;
ret = false;
}
catch (InconsistentSystem<Vector> e) {
commentator().restoreActivityState (state);
ostream &Report = commentator().report (Commentator::LEVEL_IMPORTANT, INTERNAL_ERROR);
Report << "ERROR: Inconsistent system exception" << endl;
Report << "Certificate is: ";
VD.write (Report, e.u ()) << endl;
ret = false;
commentator().restoreActivityState (state);
}
commentator().stop ("done");
commentator().progress ();
}
stream1.reset ();
stream2.reset ();
commentator().stop (MSG_STATUS (ret), (const char *) 0, "testSingularConsistentSolve");
return ret;
}