doc/html/test_lanczos2.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/DiagonalMatrix.h>
 #include <myramath/dense/DiagonalMatrixRange.h>
 #include <myramath/sparse/SparseMatrix.h>
 #include <myramath/sparse/SparseMatrixRange.h>

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

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

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

 using namespace myra;
 using namespace myra_stlprint;

 namespace {

 template<class Precision> void test(int X, int Y, Precision tolerance)
   {
   myra::out() << typestring<Precision>() << std::endl;
   // Construct 2D laplacian.
   int N = X*Y;
   auto A = laplacian2<Precision>(X,Y);
   // Compute a few dominant eigenpairs.
   int size = 8;
   Matrix<Precision> Q(N,0);
   auto VD = lanczosN(make_GemmAction(A),Q,size,tolerance,100);
   const Matrix<Precision>& V = VD.first;
   const DiagonalMatrix<Precision>& D = VD.second;
   // Evaluate residual A*V-V*D
   Matrix<Precision> R = A*V - V*D;
   Precision R_error = frobenius(R);
   myra::out() << "  |A*V-V*D| = " << R_error << std::endl;
   // Evaluate orthogonality V'V-I
   auto I = Matrix<Precision>::identity(size);
   Precision I_error = frobenius(gemm(V,'T',V)-I);
   myra::out() << "  |V'V-I| = " << I_error << std::endl;
   REQUIRE(R_error < tolerance*10.0);
   REQUIRE(I_error < tolerance*10.0);
   }

 } // namespace

 ADD_TEST("lanczos2","[iterative]")
   {
   test<float> (20,15,1.0e-4f);
   test<double>(20,15,1.0e-8);
   }
DiagonalMatrixRange.h
Interface class for representing subranges of DiagonalMatrix&#39;s.

myra::DiagonalMatrix< Precision >

MatrixRange.h
Interface class for representing subranges of dense Matrix&#39;s.

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

myra::Matrix< Precision >

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.

dimm.h
Routines for multiplying by a DiagonalMatrix.

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

myra
Definition: syntax.dox:1

myra_stlprint
Definition: stlprint.h:32

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.

myra::Matrix::identity
static Matrix< Number > identity(int IJ)
Generates an identity Matrix of specified size.
Definition: Matrix.cpp:349

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

lanczosn.h
Finds several dominant eigenpairs of a real symmetric Action.

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

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

DiagonalMatrix.h
Container for a diagonal matrix, O(n) storage. Used by SVD, row/column scaling, etc.

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

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

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.