doc/html/test_power2.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/dimm.h>
 #include <myramath/dense/gemm.h>
 #include <myramath/dense/gemv.h>
 #include <myramath/dense/inverse.h>
 #include <myramath/dense/euclidean.h>
 #include <myramath/dense/frobenius.h>
 #include <myramath/sparse/gemm.h>
 #include <myramath/sparse/gemv.h>
 #include <myramath/sparse/laplacian1.h>

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

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

 using namespace myra;
 using namespace myra_stlprint;

 namespace {

 template<class Precision> void test1(int N, Precision tolerance)
   {
   myra::out() << typestring<Precision>() << std::endl;
   // Construct input A
   auto D = DiagonalMatrix<Precision>::logspace(1,-2,N);
   auto Y = Matrix<Precision>::random(N,N);
   auto A = Y*D*inverse(Y);
   // Extract eigenpair (lambda,x)
   auto x = Vector<Precision>::random(N);
   Precision lambda = power(make_GemmAction(A),x,tolerance,200);
   // Evaluate residual A*x-lambda*x
   Vector<Precision> r = A*x - x*lambda;
   Precision r_error = euclidean(r);
   myra::out() << "  |A*x-x*lambda| = " << r_error << std::endl;
   REQUIRE(r_error < tolerance);
   }

 template<class Precision> void test2(int N, int K, Precision tolerance)
   {
   myra::out() << typestring<Precision>() << std::endl;
   // Construct input A
   auto D = DiagonalMatrix<Precision>::logspace(1,-2,N);
   auto Y = Matrix<Precision>::random(N,N);
   auto A = Y*D*inverse(Y);
   // Extract eigenpair (Lambda,X)
   auto X = Matrix<Precision>::random(N,K);
   auto Lambda = power(make_GemmAction(A),X,tolerance,200);
   // Evaluate residual A*X-X*Lambda
   Matrix<Precision> R = A*X - X*Lambda;
   Precision R_error = frobenius(R);
   myra::out() << "  |A*X-X*Lambda| = " << R_error << std::endl;
   REQUIRE(R_error < tolerance*10);
   }

 } // namespace

 ADD_TEST("power1","[iterative]")
   {
   test1<float> (20,1.0e-3f);
   test1<double>(20,1.0e-5);
   }

 ADD_TEST("power2","[iterative]")
   {
   test2<float> (20,5,1.0e-4f);
   test2<double>(20,5,1.0e-8);
   }
power.h
Applies the power method to extract dominant eigenpair.

euclidean.h
Routines for computing euclidean norm of a Vector/VectorRange, or normalizing a Vector/VectorRange to...

DiagonalMatrixRange.h
Interface class for representing subranges of DiagonalMatrix&#39;s.

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.

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

dimm.h
Routines for multiplying by a DiagonalMatrix.

myra::DiagonalMatrix::logspace
static DiagonalMatrix< Number > logspace(Precision x0, Precision x1, int N)
Generates a Vector filled with N Number&#39;s logarithmically spaced between (10^x0,10^x1).

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

gemv.h
Variety of routines all for dense Matrix*Vector multiplies. All just delegate to gemm() ...

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

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

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

myra::Vector
Tabulates a vector of length N, allows random access.
Definition: conjugate.h:21

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

inverse.h
Overwrites a LowerMatrix, DiagonalMatrix, or square Matrix with its own inverse. Or, returns it as a copy.

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.

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

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.

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