pher2k2

Source: tests/pdense/pher2k2.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/LowerMatrix.h>
#include <myramath/dense/LowerMatrixRange.h>

// Serial algorithms.
#include <myramath/utility/random.h>
#include <myramath/dense/her2k.h>
#include <myramath/dense/frobenius.h>

// Parallel algorithms.
#include <myramath/pdense/pher2k.h>
#include <myramath/pdense/Options.h>

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

using namespace myra;
typedef pdense::Options Options;

namespace {

template<class Precision> void test(int I, int J, Precision tolerance)
  {
  typedef std::complex<Precision> Number;
  myra::out() << typestring<Number>() << std::endl;
  // Generate random matrix A and B.
  auto A = Matrix<Number>::random(I,J);
  auto B = Matrix<Number>::random(I,J);
  Number alpha = random<Number>();
  Precision beta = random<Precision>();
  // Initialize options.
  auto options = Options::create().set_nthreads(4).set_blocksize(128);
  // Check her2k('N')
    {
    auto C_serial = LowerMatrix<Number>::random(I);
    for (int i = 0; i < I; ++i)
      C_serial(i,i) = std::real(C_serial(i,i));
    auto C_parallel = C_serial;
    her2k_inplace(C_serial,A,B,'N',alpha,beta);
    pher2k_inplace(C_parallel,A,B,'N',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |her2k('N')-pher2k('N')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check her2k('T')
    {
    auto C_serial = LowerMatrix<Number>::random(J);
    for (int j = 0; j < J; ++j)
      C_serial(j,j) = std::real(C_serial(j,j));
    auto C_parallel = C_serial;
    her2k_inplace(C_serial,A,B,'T',alpha,beta);
    pher2k_inplace(C_parallel,A,B,'T',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |her2k('T')-pher2k('T')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check her2k('H')
    {
    auto C_serial = LowerMatrix<Number>::random(J);
    for (int j = 0; j < J; ++j)
      C_serial(j,j) = std::real(C_serial(j,j));
    auto C_parallel = C_serial;
    her2k_inplace(C_serial,A,B,'H',alpha,beta);
    pher2k_inplace(C_parallel,A,B,'H',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |her2k('H')-pher2k('H')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check her2k('C')
    {
    auto C_serial = LowerMatrix<Number>::random(I);
    for (int i = 0; i < I; ++i)
      C_serial(i,i) = std::real(C_serial(i,i));
    auto C_parallel = C_serial;
    her2k_inplace(C_serial,A,B,'C',alpha,beta);
    pher2k_inplace(C_parallel,A,B,'C',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |her2k('C')-pher2k('C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  }

} // namespace

ADD_TEST("pher2k2","[pdense][parallel]")
  {
  int I = 512;
  int J = 256;
  test<float > (I,J,1.0e-4f);
  test<double> (I,J,1.0e-8);
  }

Results: [PASS]

std::complex<float>
  |her2k('N')-pher2k('N')| = 3.75736e-08
  |her2k('T')-pher2k('T')| = 5.82294e-08
  |her2k('H')-pher2k('H')| = 5.82239e-08
  |her2k('C')-pher2k('C')| = 3.81043e-08
std::complex<double>
  |her2k('N')-pher2k('N')| = 1.15687e-16
  |her2k('T')-pher2k('T')| = 1.42385e-16
  |her2k('H')-pher2k('H')| = 1.4353e-16
  |her2k('C')-pher2k('C')| = 1.15855e-16

Go back to Summary of /test programs.