doc/html/test_IdentityAction.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>

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

 // Iterative solve/action stuff.
 #include <myramath/iterative/Action.h>
 #include <myramath/iterative/IdentityAction.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 an identity_Action of specified size.
   Action<Number> action = make_IdentityAction<Number>(I);
   // Check action.make_Matrix()
     {
     Precision error = frobenius(action.make_Matrix()-Matrix<Number>::identity(I));
     myra::out() << "  |I(action) - I(matrix)| = " << 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(X-B);
     myra::out() << "  |I*X - X| = " << 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*X + beta*B;
     action.multiply(X,B,alpha,beta);
     Precision error = frobenius(B-C);
     myra::out() << "  | (alpha*I*X+beta*B) - (alpha*X+beta*B) | = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   }

 } // namespace

 ADD_TEST("IdentityAction","[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

IdentityAction.h
An Action that is just the identity 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

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

myra::Action
Applies the "Action" of a linear operator, b := A*x.
Definition: Action.h:29

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

myra::Action::make_Matrix
Matrix< Number > make_Matrix() const
Tabulates *this into a dense Matrix.
Definition: Action.cpp:71

random.h
Simplistic random number functions.

myra::Action::multiply
void multiply(const CMatrixRange< Number > &X, const MatrixRange< Number > &B, Number alpha, Number beta) const
Assigns B = alpha*A*X + beta*B.
Definition: Action.cpp:55