doc/html/test_bothcat_Action.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/utility/Array2.h>
 #include <myramath/dense/Matrix.h>
 #include <myramath/dense/MatrixRange.h>

 // Algorithms.
 #include <myramath/dense/frobenius.h>
 #include <myramath/dense/bothcat.h>

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

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

 using namespace myra;

 namespace {

 // Tests bothcat(A,B,C,D)
 template<class Number> void test1(typename ReflectPrecision<Number>::type tolerance)
   {
   typedef typename ReflectPrecision<Number>::type Precision;
   auto A0 = Matrix<Number>::random(5,5);
   auto B0 = Matrix<Number>::random(5,3);
   auto C0 = Matrix<Number>::random(3,5);
   auto D0 = Matrix<Number>::random(3,3);
   auto E0 = bothcat(A0,B0,C0,D0);
   auto A = make_GemmAction(A0);
   auto B = make_GemmAction(B0);
   auto C = make_GemmAction(C0);
   auto D = make_GemmAction(D0);
   auto E = bothcat(A,B,C,D);
   Precision error = frobenius(E0-E.make_Matrix());
   myra::out() << "  |E0-E| = " << error << std::endl;
   REQUIRE(error < tolerance);
   }

 #ifdef MYRAMATH_ENABLE_CPP11

 // Tests bothcat(A,B,C,D,E,F)
 template<class Number> void test2(typename ReflectPrecision<Number>::type tolerance)
   {
   typedef typename ReflectPrecision<Number>::type Precision;
   auto A0 = Matrix<Number>::random(5,5);
   auto B0 = Matrix<Number>::random(5,3);
   auto C0 = Matrix<Number>::random(5,7);
   auto D0 = Matrix<Number>::random(4,5);
   auto E0 = Matrix<Number>::random(4,3);
   auto F0 = Matrix<Number>::random(4,7);
   auto G0 = bothcat({2,3,{A0,B0,C0,D0,E0,F0}});
   auto A = make_GemmAction(A0);
   auto B = make_GemmAction(B0);
   auto C = make_GemmAction(C0);
   auto D = make_GemmAction(D0);
   auto E = make_GemmAction(E0);
   auto F = make_GemmAction(F0);
   auto G = bothcat({2,3,{A,B,C,D,E,F}});
   Precision error = frobenius(G0-G.make_Matrix());
   myra::out() << "  |G0-G| = " << error << std::endl;
   REQUIRE(error < tolerance);
   }

 #endif

 }

 ADD_TEST("bothcat_Action","[iterative]")
   {
   test1<NumberS>(1.0e-5f);
   test1<NumberD>(1.0e-10);
   test1<NumberC>(1.0e-5f);
   test1<NumberZ>(1.0e-10);
   }

 #ifdef MYRAMATH_ENABLE_CPP11

 ADD_TEST("bothcat_Action_cpp11","[iterative]")
   {
   test2<NumberS>(1.0e-5f);
   test2<NumberD>(1.0e-10);
   test2<NumberC>(1.0e-5f);
   test2<NumberZ>(1.0e-10);
   }

 #endif

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.

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

Array2.h
Container of values, allows random (i,j) access.

bothcat.h
Routines to concatenate Action&#39;s in two-by-two fashion.

myra
Definition: syntax.dox:1

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

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

bothcat.h
Routines to concatenate Matrix&#39;s in two-by-two fashion.