dimmR

Source: tests/dense/dimm.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/dense/Matrix.h>
#include <myramath/dense/MatrixRange.h>
#include <myramath/dense/DiagonalMatrix.h>
#include <myramath/dense/DiagonalMatrixRange.h>

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

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

using namespace myra;

namespace {

// Make random D and X, try all dimm('L',op) variations.
template<class Number> void test1(int I, int J, typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto D = DiagonalMatrix<Number>::random(I);
  auto X = Matrix<Number>::random(I,J);
  Precision errorN = frobenius(dimm('L','N',D,X)-gemm(D.make_Matrix(),'N',X,'N'));
  Precision errorT = frobenius(dimm('L','T',D,X)-gemm(D.make_Matrix(),'T',X,'N'));
  Precision errorH = frobenius(dimm('L','H',D,X)-gemm(D.make_Matrix(),'H',X,'N'));
  Precision errorC = frobenius(dimm('L','C',D,X)-gemm(D.make_Matrix(),'C',X,'N'));
  myra::out() << "error |D^N * X| = " << errorN << std::endl;
  myra::out() << "error |D^T * X| = " << errorT << std::endl;  
  myra::out() << "error |D^H * X| = " << errorH << std::endl;
  myra::out() << "error |D^C * X| = " << errorC << std::endl;
  REQUIRE(errorN < tolerance);
  REQUIRE(errorT < tolerance);
  REQUIRE(errorH < tolerance);
  REQUIRE(errorC < tolerance);
  }

// Make random D and X, try all dimm('R',op) variations.
template<class Number> void test2(int I, int J, typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto D = DiagonalMatrix<Number>::random(J);
  auto X = Matrix<Number>::random(I,J);
  Precision errorN = frobenius(dimm('R','N',D,X)-gemm(X,'N',D.make_Matrix(),'N'));
  Precision errorT = frobenius(dimm('R','T',D,X)-gemm(X,'N',D.make_Matrix(),'T'));
  Precision errorH = frobenius(dimm('R','H',D,X)-gemm(X,'N',D.make_Matrix(),'H'));
  Precision errorC = frobenius(dimm('R','C',D,X)-gemm(X,'N',D.make_Matrix(),'C'));
  myra::out() << "error |X * D^N| = " << errorN << std::endl;
  myra::out() << "error |X * D^T| = " << errorT << std::endl;
  myra::out() << "error |X * D^H| = " << errorH << std::endl;
  myra::out() << "error |X * D^C| = " << errorC << std::endl;
  REQUIRE(errorN < tolerance);
  REQUIRE(errorT < tolerance);
  REQUIRE(errorH < tolerance);
  REQUIRE(errorC < tolerance);
  }

} // namespace

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

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

Results: [PASS]

error |X * D^N| = 0
error |X * D^T| = 0
error |X * D^H| = 0
error |X * D^C| = 0
error |X * D^N| = 0
error |X * D^T| = 0
error |X * D^H| = 0
error |X * D^C| = 0
error |X * D^N| = 0
error |X * D^T| = 0
error |X * D^H| = 0
error |X * D^C| = 0
error |X * D^N| = 0
error |X * D^T| = 0
error |X * D^H| = 0
error |X * D^C| = 0

Go back to Summary of /test programs.