doc/html/test_rcholesky2_mixed.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/Vector.h>
 #include <myramath/dense/VectorRange.h>
 #include <myramath/sparse/SparseMatrix.h>
 #include <myramath/sparse/SparseMatrixRange.h>
 #include <myramath/sparse/Permutation.h>

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

 // Solver under test.
 #include <myramath/multifrontal/rcholesky/SparseRCholeskySolver.h>

 // Details for setting up refinement.
 #include <myramath/iterative/mixed_refine.h>
 #include <myramath/iterative/GemmAction.h>
 #include <myramath/iterative/SolveAction.h>

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

 using namespace myra;
 using namespace myra_stlprint;

 ADD_TEST("rcholesky2_mixed","[multifrontal][parallel]")
   {
   // Define problem size.
   int I = 64;
   int J = 64;
   int N = I*J;
   // Make laplacian matrix A in double precision.
   SparseMatrix<double> A = laplacian2<double>(I,J);
   // Factor A = L*L' in float precision.
   SparseRCholeskySolver<float> solver( lower_precision(A) );
   // Make random b and x.
   auto b = Vector<double>::random(N);
   auto x = Vector<double>::zeros(N);
   x = b;
   // Solve A*x = b with pcg(), using the single precision solver as a preconditioner.
   auto history = mixed_refine( make_GemmAction(A), make_SolveAction(solver), x, 1.0e-12, 20);
   // Verify a low residual tolerance was reached.
   double error = frobenius(A*x-b);
   myra::out() << "  error = " << error << std::endl;
   myra::out() << "  history = " << history << std::endl;
   REQUIRE(error < 1.0e-10);
   }

VectorRange.h
Interface class for representing subranges of dense Vector&#39;s.

gemm.h
Variety of routines for mixed dense*sparse or dense*sparse matrix multiplies. The dense*dense case is...

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

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

SparseMatrix.h
General purpose compressed-sparse-column (CSC) container.

myra::Vector::random
static Vector< Number > random(int N)
Generates a random Vector of specified size.
Definition: Vector.cpp:276

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.

gemv.h
Signatures for sparse matrix * dense vector multiplies. All delegate to gemm() under the hood...

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

myra::Vector::zeros
static Vector< Number > zeros(int N)
Generates a zeros Vector of specified size.
Definition: Vector.cpp:280

SparseRCholeskySolver.h
Sparse direct solver suitable for real symmetric positive definite systems.

Vector.h
Container for either a column vector or row vector (depends upon the usage context) ...

Permutation.h
Aggregates a (perm, iperm, swaps) triple into a vocabulary type.

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::SparseRCholeskySolver
Sparse direct solver suitable for real symmetric positive definite systems.
Definition: SparseRCholeskySolver.h:61

myra::SparseMatrix
Stores an IxJ matrix A in compressed sparse column format.
Definition: bothcat.h:23

laplacian2.h
Helper routines for reordering/filling 2D structured grids. Used by many unit tests.

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.