inline bool MatrixMatrixTester<Scalar>
::diagRightProdTest() const
{
if (diagRightProdSpec_.doTest())
{
Out::root() << "running diagonal*matrix multiplication test..." << std::endl;
Vector<Scalar> x = A_.domain().createMember();
randomizeVec(x);
Vector<Scalar> d = A_.domain().createMember();
randomizeVec(d);
LinearOperator<Scalar> D = diagonalOperator(d);
LinearOperator<Scalar> AD = epetraRightScale(A_, d);
Out::root() << "computing implicit y1 = A*D*x..." << std::endl;
Vector<Scalar> y1 = A_*D*x;
Out::root() << "computing explicit y2 = A*D*x..." << std::endl;
Vector<Scalar> y2 = AD*x;
ScalarMag err = (y1 - y2).norm2();
Out::root() << "|y1-y2| = " << err << std::endl;
return checkTest(diagLeftProdSpec_, err, "matrix*diagonal multiplication");
}
Out::root() << "skipping diagonal matrix-matrix test..." << std::endl;
return true;
}
inline bool CompoundTester<Scalar>
::diagTest() const
{
if (diagSpec_.doTest())
{
Out::root() << "running diagonal operator test..." << std::endl;
Vector<Scalar> x = A_.domain().createMember();
randomizeVec(x);
Vector<Scalar> d = A_.domain().createMember();
randomizeVec(d);
LinearOperator<Scalar> D = diagonalOperator(d);
Out::root() << "computing y1 = D*x..." << std::endl;
Vector<Scalar> y1 = D*x;
Out::root() << "computing y2 = d .* x..." << std::endl;
Vector<Scalar> y2 = x.dotStar(d);
ScalarMag err = (y1 - y2).norm2();
Out::root() << "|y1-y2| = " << err << std::endl;
return checkTest(diagSpec_, err, "diagonal operator");
}
Out::root() << "skipping diagonal operator test..." << std::endl;
return true;
}
inline bool MatrixMatrixTester<Scalar>
::diagTest() const
{
if (diagSpec_.doTest())
{
Vector<Scalar> x = B_.domain().createMember();
Vector<Scalar> d = B_.domain().createMember();
randomizeVec(x);
randomizeVec(d);
LinearOperator<Scalar> D0 = diagonalOperator(d);
LinearOperator<Scalar> D = makeEpetraDiagonalMatrix(d);
Vector<Scalar> d1 = getEpetraDiagonal(D);
Out::root() << "computing implicit product y1 = D*x..." << std::endl;
Vector<Scalar> y1 = D0*x;
Out::root() << "computing explicit product y2 = D*x..." << std::endl;
Vector<Scalar> y2 = D*x;
ScalarMag err = (y1 - y2).norm2();
Out::root() << "|y1-y2| = " << err << std::endl;
Out::root() << "comparing recovered and original diagonals" << std::endl;
ScalarMag err2 = (d - d1).norm2();
Out::root() << "|d1-d2| = " << err2 << std::endl;
return checkTest(prodSpec_, err+err2, "matrix-matrix multiply");
}
Out::root() << "skipping matrix-matrix multiply test..." << std::endl;
return true;
}
inline bool CompoundTester<Scalar>
::scaledTest() const
{
if (scaledSpec_.doTest())
{
Out::root() << "running operator scaling test..." << std::endl;
Scalar alpha = sqrt(2.0);
LinearOperator<Scalar> scaled = alpha*A_;
Vector<Scalar> x = A_.domain().createMember();
randomizeVec(x);
Out::root() << "computing y1 = (alpha*A)*x..." << std::endl;
Vector<Scalar> y1 = scaled*x;
Out::root() << "computing y2 = A*x..." << std::endl;
Vector<Scalar> y2 = A_*x;
Out::root() << "computing y3 = alpha*y2..." << std::endl;
Vector<Scalar> y3 = alpha*y2;
ScalarMag err = (y1 - y3).norm2();
Out::root() << "|y1-y3| = " << err << std::endl;
return checkTest(composedSpec_, err, "operator scaling");
}
Out::root() << "skipping operator scaling test..." << std::endl;
return true;
}
inline bool CompoundTester<Scalar>
::composedTest() const
{
if (composedSpec_.doTest())
{
Out::root() << "running operator composition test..." << std::endl;
LinearOperator<Scalar> composed = A_ * B_;
Vector<Scalar> x = B_.domain().createMember();
randomizeVec(x);
Out::root() << "computing y1 = (A*B)*x..." << std::endl;
Vector<Scalar> y1 = composed*x;
Out::root() << "computing y2 = B*x..." << std::endl;
Vector<Scalar> y2 = B_*x;
Out::root() << "computing y3 = A*y2..." << std::endl;
Vector<Scalar> y3 = A_*y2;
ScalarMag err = (y1 - y3).norm2();
Out::root() << "|y1-y3| = " << err << std::endl;
return checkTest(composedSpec_, err, "operator composition");
}
Out::root() << "skipping operator composition test..." << std::endl;
return true;
}
inline bool MatrixMatrixTester<Scalar>
::sumTest() const
{
if (sumSpec_.doTest())
{
/* skip incompatible matrices. This will occur when we're testing
* multiplication of rectangular matrices */
if (A_.range() != B_.range() || A_.domain() != B_.domain())
{
Out::root() << "skipping sum on incompatible matrices" << std::endl;
return true;
}
/* If here, the sum should work */
Out::root() << "running matrix-matrix multiply test..." << std::endl;
LinearOperator<Scalar> implicitAdd = A_ + B_;
LinearOperator<Scalar> explicitAdd = epetraMatrixMatrixSum(A_, B_);
Vector<Scalar> x = B_.domain().createMember();
randomizeVec(x);
Out::root() << "computing implicit sum y1 = (A+B)*x..." << std::endl;
Vector<Scalar> y1 = implicitAdd*x;
Out::root() << "computing explicit sum y2 = (A+B)*x..." << std::endl;
Vector<Scalar> y2 = explicitAdd*x;
ScalarMag err = (y1 - y2).norm2();
Out::root() << "|y1-y2| = " << err << std::endl;
return checkTest(prodSpec_, err, "matrix-matrix multiply");
}
Out::root() << "skipping matrix-matrix multiply test..." << std::endl;
return true;
}
inline bool CompoundTester<Scalar>
::sumTest() const
{
if (sumSpec_.doTest())
{
Out::root() << "running operator addition test..." << std::endl;
LinearOperator<Scalar> sum = A_ + B_;
Vector<Scalar> x = A_.domain().createMember();
randomizeVec(x);
Out::root() << "computing y1 = (A+B)*x..." << std::endl;
Vector<Scalar> y1 = sum*x;
Out::root() << "computing y2 = A*x + B*x..." << std::endl;
Vector<Scalar> y2 = A_*x + B_*x;
ScalarMag err = (y1 - y2).norm2();
Out::root() << "|y1-y2| = " << err << std::endl;
return checkTest(sumSpec_, err, "operator addition");
}
Out::root() << "skipping operator addition test..." << std::endl;
return true;
}
inline bool MatrixMatrixTester<Scalar>
::prodTest() const
{
if (prodSpec_.doTest())
{
Out::root() << "running matrix-matrix multiply test..." << std::endl;
LinearOperator<Scalar> composed = A_ * B_;
LinearOperator<Scalar> multiplied = epetraMatrixMatrixProduct(A_, B_);
Vector<Scalar> x = B_.domain().createMember();
randomizeVec(x);
Out::root() << "computing implicit product y1 = (A*B)*x..." << std::endl;
Vector<Scalar> y1 = composed*x;
Out::root() << "computing explicit product y2 = (A*B)*x..." << std::endl;
Vector<Scalar> y2 = multiplied*x;
ScalarMag err = (y1 - y2).norm2();
Out::root() << "|y1-y2| = " << err << std::endl;
return checkTest(prodSpec_, err, "matrix-matrix multiply");
}
Out::root() << "skipping matrix-matrix multiply test..." << std::endl;
return true;
}
Vector3 utils3D::getRandomizedVectorP1ToP2(const Vector3& p1, const Vector3& p2, float fudge)
{
Vector3 vec(p2 - p1);
return randomizeVec( vec, fudge );
}
