DimmAction

Source: tests/iterative/DimmAction.cpp

// ========================================================================= //
// 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/DiagonalMatrix.h>
#include <myramath/dense/DiagonalMatrixRange.h>

// Algorithms.
#include <myramath/utility/random.h>
#include <myramath/dense/dimm.h>
#include <myramath/dense/frobenius.h>
#include <myramath/iterative/Action.h>
#include <myramath/iterative/DimmAction.h>

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

using namespace myra;
using namespace myra_stlprint;

namespace {

// Test make_DimmAction()
template<class Number> void test(int IJ, int K, typename ReflectPrecision<Number>::type tolerance)
  {  
  myra::out() << typestring<Number>() << std::endl;
  typedef typename ReflectPrecision<Number>::type Precision;
  // Make a random DiagonalMatrix A, wrap it up into a DimmAction
  auto A = DiagonalMatrix<Number>::random(IJ);
  auto action = make_DimmAction(A);
  // Check action.make_Matrix()
    {
    Precision error = frobenius(action.make_Matrix()-A.make_Matrix());
    myra::out() << "  |A(action) - A(dense)| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check action.multiply(X,B)
    {
    auto X = Matrix<Number>::random(IJ,K);
    auto B = Matrix<Number>::zeros(IJ,K);
    action.multiply(X,B);
    Precision error = frobenius(A*X-B);
    myra::out() << "  |A*X - B| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check action.multiply(X,B,alpha,beta)
    {
    auto X = Matrix<Number>::random(IJ,K);
    auto B = Matrix<Number>::random(IJ,K);
    auto alpha = random<Number>();
    auto beta  = random<Number>();
    auto C = alpha*A*X + beta*B;
    action.multiply(X,B,alpha,beta);
    Precision error = frobenius(B-C);
    myra::out() << "  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  }

} // namespace

ADD_TEST("DimmAction","[iterative]")
  {
  // Test make_DimmAction()
  int IJ = 10;
  int K = 7;
  test<NumberS>(IJ,K,1.0e-4f);
  test<NumberD>(IJ,K,1.0e-12);
  test<NumberC>(IJ,K,1.0e-4f);
  test<NumberZ>(IJ,K,1.0e-12);
  }

Results: [PASS]

float
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 4.90162e-08
double
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 3.64275e-16
std::complex<float>
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 3.78002e-07
std::complex<double>
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 8.31973e-16

Go back to Summary of /test programs.