doc/html/test_zldlh2_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/phasor.h>
 #include <myramath/sparse/gemm.h>
 #include <myramath/sparse/gemv.h>
 #include <myramath/sparse/lower_precision.h>

 // Solver under test.
 #include <myramath/multifrontal/zldlh/SparseZLDLHSolver.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("zldlh2_mixed","[multifrontal][parallel]")
   {
   // Define problem size.
   int I = 64;
   int J = 64;
   int N = I*J;
   // Make laplacian matrix A in double precision, shift to make it indefinite.
   SparseMatrix<NumberZ> A = laplacian2<NumberZ>(I,J);
   for (int n = 0; n < N; ++n)
     A(n,n) -= 5.5;
   phasor_hermitian(A);
   // Factor A = L*D*L' in float precision.
   SparseZLDLHSolver<float> solver(lower_precision(A));
   // Make random b and x.
   auto b = Vector<NumberZ>::random(N);
   auto x = Vector<NumberZ>::zeros(N);
   x = b;
   // Solve A*x = b with mixed_refine(), using the single precision solver as a preconditioner.
   auto history = mixed_refine( make_GemmAction(A), make_SolveAction(solver), x, 1.0e-12, 20);
   double error = frobenius(A*x-b);
   myra::out() << "  error = " << error << std::endl;
   myra::out() << "  history = " << history << std::endl;
   REQUIRE(error < 1.0e-10);
   }

SparseZLDLHSolver.h
Sparse direct solver suitable for complex hermitian indefinite systems.

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.

myra::SparseZLDLHSolver
Sparse direct solver suitable for complex hermitian indefinite systems.
Definition: SparseZLDLHSolver.h:60

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

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::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.

phasor.h
Applies random phase shifts to a complex square SparseMatrix.

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.