doc/html/test_SolveAction.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/LUSolver.h>

 // Algorithms.
 #include <myramath/utility/random.h>
 #include <myramath/dense/gemm.h>
 #include <myramath/dense/inverse.h>
 #include <myramath/dense/frobenius.h>

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

 // Reporting.
 #include <tests/myratest.h>

 using namespace myra;

 namespace {

 template<class Number> void test(int I, int J, typename ReflectPrecision<Number>::type tolerance)
   {
   myra::out() << typestring<Number>() << std::endl;
   typedef typename ReflectPrecision<Number>::type Precision;
   // Make a random Matrix A..
   auto A = Matrix<Number>::random(I,I);
   // .. generate an LUSolver for it
   typedef LUSolver<Number> Solver;
   Solver solver(A.add_const());
   // .. wrap that up into a make_SolveAction()
   auto action = make_SolveAction(solver);
   // Check action.make_Matrix() - should be same as inverse(A)
     {
     Precision error = frobenius(action.make_Matrix()-inverse(A));
     myra::out() << "  |action.make_Matrix() - inv(A)| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   // Check action.multiply(X,B)
     {
     auto X = Matrix<Number>::random(I,J);
     auto B = Matrix<Number>::zeros(I,J);
     action.multiply(X,B);
     Precision error = frobenius(inverse(A)*X-B);
     myra::out() << "  |inv(A)*X - B| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   // Check action.multiply(X,B,alpha,beta)
     {
     auto X = Matrix<Number>::random(I,J);
     auto B = Matrix<Number>::random(I,J);
     auto alpha = random<Number>();
     auto beta  = random<Number>();
     auto C = alpha*inverse(A)*X + beta*B;
     action.multiply(X,B,alpha,beta);
     Precision error = frobenius(B-C);
     myra::out() << "  | (alpha*inv(A)*X+beta*B)[action] - (alpha*inv(A)*X+beta*B)[matrix] | = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   }

 } // namespace

 ADD_TEST("SolveAction","[iterative]")
   {
   int I = 10;
   int J = 5;
   test<NumberS>(I,J,1.0e-4f);
   test<NumberD>(I,J,1.0e-12);
   test<NumberC>(I,J,1.0e-4f);
   test<NumberZ>(I,J,1.0e-12);
   }
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::zeros
static Matrix< Number > zeros(int I, int J)
Generates a zeros Matrix of specified size.
Definition: Matrix.cpp:357

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

myra
Definition: syntax.dox:1

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

Number.h
Various utility functions/classes related to scalar Number types.

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

myra::ReflectPrecision
Reflects Precision trait for a Number, scalar Number types should specialize it.
Definition: Number.h:33

LUSolver.h
General purpose linear solver, no symmetry/definiteness assumptions upon A (just square) ...

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

SolveAction.h
Adapts a class with a .solve() method into an Action.

myra::LUSolver
Factors a square matrix A into L*U, presents solve methods.
Definition: LUSolver.h:30

random.h
Simplistic random number functions.

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