sparse_dimm

Source: tests/sparse/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>
#include <myramath/sparse/SparseMatrix.h>
#include <myramath/sparse/SparseMatrixRange.h>

// Algorithms.
#include <myramath/dense/dimm.h>
#include <myramath/dense/frobenius.h>
#include <myramath/sparse/dimm.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, int N, typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto D = DiagonalMatrix<Number>::random(I);
  auto X = SparseMatrix<Number>::random(I,J,N);
  Precision errorN = frobenius(dimm('L','N',D,X).make_Matrix()-dimm('L','N',D,X.make_Matrix()));
  Precision errorT = frobenius(dimm('L','T',D,X).make_Matrix()-dimm('L','T',D,X.make_Matrix()));
  Precision errorH = frobenius(dimm('L','H',D,X).make_Matrix()-dimm('L','H',D,X.make_Matrix()));
  Precision errorC = frobenius(dimm('L','C',D,X).make_Matrix()-dimm('L','C',D,X.make_Matrix()));
  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, int N, typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto D = DiagonalMatrix<Number>::random(J);
  auto X = SparseMatrix<Number>::random(I,J,N);
  Precision errorN = frobenius(dimm('R','N',D,X).make_Matrix()-dimm('R','N',D,X.make_Matrix()));
  Precision errorT = frobenius(dimm('R','T',D,X).make_Matrix()-dimm('R','T',D,X.make_Matrix()));
  Precision errorH = frobenius(dimm('R','H',D,X).make_Matrix()-dimm('R','H',D,X.make_Matrix()));
  Precision errorC = frobenius(dimm('R','C',D,X).make_Matrix()-dimm('R','C',D,X.make_Matrix()));
  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("sparse_dimm","[sparse]")
  {
  test1<NumberS>(100,50,500,1.0e-4f);
  test1<NumberD>(100,50,500,1.0e-10);
  test1<NumberC>(100,50,500,1.0e-4f);
  test1<NumberZ>(100,50,500,1.0e-10);
  test2<NumberS>(100,50,500,1.0e-4f);
  test2<NumberD>(100,50,500,1.0e-10);
  test2<NumberC>(100,50,500,1.0e-4f);
  test2<NumberZ>(100,50,500,1.0e-10);
  };

Results: [PASS]

error |D^N * X| = 0
error |D^T * X| = 0
error |D^H * X| = 0
error |D^C * X| = 0
error |D^N * X| = 0
error |D^T * X| = 0
error |D^H * X| = 0
error |D^C * X| = 0
error |D^N * X| = 0
error |D^T * X| = 0
error |D^H * X| = 0
error |D^C * X| = 0
error |D^N * X| = 0
error |D^T * X| = 0
error |D^H * X| = 0
error |D^C * X| = 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
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.