doc/html/test_lanczos1.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/Vector.h>
 #include <myramath/dense/DiagonalMatrix.h>
 #include <myramath/dense/MatrixRange.h>
 #include <myramath/dense/VectorRange.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/lanczos1.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 K = 8;
   Matrix<Precision> V(N,K);
   DiagonalMatrix<Precision> D(K);
   for (int k = 0; k < K; ++k)
     {
     auto v_d = lanczos1(make_GemmAction(A),V,tolerance,100);
     V.vector(k).assign(v_d.first);
     D(k) = v_d.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(K);
   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("lanczos1","[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.

VectorRange.h
Interface class for representing subranges of dense Vector&#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...

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

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

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

lanczos1.h
Finds one dominant eigenpair of a real symmetric Action.

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.