NegateAction

Source: tests/iterative/NegateAction.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>

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

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

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

using namespace myra;

namespace {

// Test negate_action().
template<class Number> void test1(int I, int J, int K, typename ReflectPrecision<Number>::type tolerance)
  {  
  myra::out() << typestring<Number>() << std::endl;
  typedef typename ReflectPrecision<Number>::type Precision;
  // Form A.
  auto A = Matrix<Number>::random(I,J);
  auto action = -make_GemmAction(A);
  // Check action.make_Matrix()
    {
    Precision error = frobenius(-A-action.make_Matrix());
    myra::out() << "  |A(action) - A(dense)| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check A_action.multiply(X,B)
    {
    auto X = Matrix<Number>::random(J,K);
    auto B = Matrix<Number>::zeros(I,K);
    action.multiply(X,B);
    Precision error = frobenius(-A*X-B);
    myra::out() << "  |A*X - B| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check A_action.multiply(X,B,alpha,beta)
    {
    auto X = Matrix<Number>::random(J,K);
    auto B = Matrix<Number>::random(I,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("NegateAction","[iterative]")
  {
  // Test dense make_TrsmAction()
  int I = 10;
  int J = 7;
  int K = 4;
  test1<NumberS>(I,J,K,1.0e-4f);
  test1<NumberD>(I,J,K,1.0e-10);
  test1<NumberC>(I,J,K,1.0e-4f);
  test1<NumberZ>(I,J,K,1.0e-10);
  }

Results: [PASS]

float
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 0
double
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 0
std::complex<float>
  |A(action) - A(dense)| = 0
  |A*X - B| = 0
  | (alpha*A*X+beta*B)[action] - (alpha*A*X+beta*B)[dense] | = 6.51404e-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] | = 1.07295e-15

Go back to Summary of /test programs.