doc/html/test_mixed_refine.html

 // ========================================================================= //
 // This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
 // and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
 // ========================================================================= //

 // Containers.
 #include <myramath/utility/Number.h>
 #include <myramath/dense/Matrix.h>
 #include <myramath/dense/MatrixRange.h>
 #include <myramath/dense/LUSolver.h>

 // Algorithms.
 #include <myramath/dense/gemm.h>
 #include <myramath/dense/lower_precision.h>
 #include <myramath/dense/frobenius.h>

 // Iterative solve/action stuff.
 #include <myramath/iterative/Action.h>
 #include <myramath/iterative/GemmAction.h>
 #include <myramath/iterative/SolveAction.h>
 #include <myramath/iterative/mixed_refine.h>

 // Reporting.
 #include <myramath/utility/stlprint.h>
 #include <tests/myratest.h>

 using namespace myra;
 using namespace myra_stlprint;

 namespace {

 template<class Double> void test(int I, int J)
   {
   // Deduce low precision Number type.
   typedef typename LowerPrecision<Double>::type Float;
   // Form random double precision A..
   auto A_double = Matrix<Double>::random(I,I);
   auto A_action = make_GemmAction(A_double);
   // .. generate float precision LUSolver for it
   auto A_float  = lower_precision(A_double);
   typedef LUSolver<Float> Solver;
   Solver solver(A_float);
   auto M_action = make_SolveAction(solver);
   // .. generate random X, form A*X=B
   auto X = Matrix<Double>::random(I,J);
   auto B = A_double*X;
   // .. solve A*X=B using refine(), by raising the precision of M_action
   auto history = mixed_refine(A_action, M_action, B, 1.0e-14, 10);
   double error = frobenius(B-X)/ frobenius(X);
   myra::out() << "  |inv(A)*B-X| = " << error << std::endl;
   myra::out() << "  history = " << history << std::endl;
   REQUIRE(error < 1.0e-10);
   }

 } // namespace

 ADD_TEST("mixed_refine","[iterative]")
   {
   int I = 50;
   int J = 10;
   test<NumberD> (I,J);
   test<NumberZ> (I,J);
   }
MatrixRange.h
Interface class for representing subranges of dense Matrix&#39;s.

lower_precision.h
Routines for copying and lowering the precision of a container.

Action.h
Applies the "Action" of a linear operator, b := A*x, used in iterative solution algorithms.

frobenius.h
Routines for computing Frobenius norms of various algebraic containers.

myra::Matrix::random
static Matrix< Number > random(int I, int J)
Generates a random Matrix of specified size.
Definition: Matrix.cpp:353

myra
Definition: syntax.dox:1

myra_stlprint
Definition: stlprint.h:32

myra::make_SolveAction
Action< typename ReflectNumber< Solver >::type > make_SolveAction(const Solver &solver, char op='N')
Free function for making SolveAction&#39;s.
Definition: SolveAction.h:67

stlprint.h
Routines for printing the contents of various std::container&#39;s to a std::ostream using operator <<...

Number.h
Various utility functions/classes related to scalar Number types.

mixed_refine.h
Like refine(), but uses a low-precision M to solve/refine a high-precision A.

Matrix.h
General purpose dense matrix container, O(i*j) storage.

myra::LowerPrecision
Reflectors that lower the Precision of a Number type.
Definition: Number.h:73

LUSolver.h
General purpose linear solver, no symmetry/definiteness assumptions upon A (just square) ...

SolveAction.h
Adapts a class with a .solve() method into an Action.

GemmAction.h
An Action for multiplying by a dense Matrix or SparseMatrix using gemm().

myra::LUSolver
Factors a square matrix A into L*U, presents solve methods.
Definition: LUSolver.h:30

gemm.h
Variety of routines all for dense Matrix*Matrix multiplies. Delegates to the BLAS.