psyrk1

Source: tests/pdense/psyrk1.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>

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

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

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

using namespace myra;
typedef pdense::Options Options;

namespace {

template<class Number> void test(int I, int J, typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  myra::out() << typestring<Number>() << std::endl;
  // Generate random matrix A.
  auto A = Matrix<Number>::random(I,J);
  Number alpha = random<Number>();
  Number beta = random<Number>();
  // Initialize options.
  auto options = Options::create().set_nthreads(4);
  // Check syrk('U','N')
    {
    auto C_serial = Matrix<Number>::random(I,I);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'U',A,'N',alpha,beta);
    psyrk_inplace(C_parallel,'U',A,'N',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('U','N')-psyrk('U','N')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('U','T')
    {
    auto C_serial = Matrix<Number>::random(J,J);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'U',A,'T',alpha,beta);
    psyrk_inplace(C_parallel,'U',A,'T',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('U','T')-psyrk('U','T')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('U','H')
    {
    auto C_serial = Matrix<Number>::random(J,J);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'U',A,'H',alpha,beta);
    psyrk_inplace(C_parallel,'U',A,'H',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('U','H')-psyrk('U','H')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('U','C')
    {
    auto C_serial = Matrix<Number>::random(I,I);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'U',A,'C',alpha,beta);
    psyrk_inplace(C_parallel,'U',A,'C',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('U','C')-psyrk('U','C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('L','N')
    {
    auto C_serial = Matrix<Number>::random(I,I);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'L',A,'N',alpha,beta);
    psyrk_inplace(C_parallel,'L',A,'N',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('L','N')-psyrk('L','N')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('L','T')
    {
    auto C_serial = Matrix<Number>::random(J,J);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'L',A,'T',alpha,beta);
    psyrk_inplace(C_parallel,'L',A,'T',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('L','T')-psyrk('L','T')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('L','H')
    {
    auto C_serial = Matrix<Number>::random(J,J);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'L',A,'H',alpha,beta);
    psyrk_inplace(C_parallel,'L',A,'H',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('L','H')-psyrk('L','H')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  // Check syrk('L','C')
    {
    auto C_serial = Matrix<Number>::random(I,I);
    auto C_parallel = C_serial;
    syrk_inplace(C_serial,'L',A,'C',alpha,beta);
    psyrk_inplace(C_parallel,'L',A,'C',alpha,beta,options);
    Precision error = frobenius(C_serial-C_parallel) / frobenius(C_serial);
    myra::out() << "  |syrk('L','C')-psyrk('L','C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  }

} // namespace

ADD_TEST("psyrk1","[pdense][parallel]")
  {
  int I = 512;
  int J = 256;
  test<NumberS>(I,J,1.0e-4f);
  test<NumberD>(I,J,1.0e-8);
  test<NumberC>(I,J,1.0e-4f);  
  test<NumberZ>(I,J,1.0e-8);
  }

Results: [PASS]

float
  |syrk('U','N')-psyrk('U','N')| = 0
  |syrk('U','T')-psyrk('U','T')| = 0
  |syrk('U','H')-psyrk('U','H')| = 0
  |syrk('U','C')-psyrk('U','C')| = 0
  |syrk('L','N')-psyrk('L','N')| = 0
  |syrk('L','T')-psyrk('L','T')| = 0
  |syrk('L','H')-psyrk('L','H')| = 0
  |syrk('L','C')-psyrk('L','C')| = 0
double
  |syrk('U','N')-psyrk('U','N')| = 0
  |syrk('U','T')-psyrk('U','T')| = 0
  |syrk('U','H')-psyrk('U','H')| = 0
  |syrk('U','C')-psyrk('U','C')| = 0
  |syrk('L','N')-psyrk('L','N')| = 0
  |syrk('L','T')-psyrk('L','T')| = 0
  |syrk('L','H')-psyrk('L','H')| = 0
  |syrk('L','C')-psyrk('L','C')| = 0
std::complex<float>
  |syrk('U','N')-psyrk('U','N')| = 0
  |syrk('U','T')-psyrk('U','T')| = 0
  |syrk('U','H')-psyrk('U','H')| = 0
  |syrk('U','C')-psyrk('U','C')| = 0
  |syrk('L','N')-psyrk('L','N')| = 0
  |syrk('L','T')-psyrk('L','T')| = 0
  |syrk('L','H')-psyrk('L','H')| = 0
  |syrk('L','C')-psyrk('L','C')| = 0
std::complex<double>
  |syrk('U','N')-psyrk('U','N')| = 0
  |syrk('U','T')-psyrk('U','T')| = 0
  |syrk('U','H')-psyrk('U','H')| = 0
  |syrk('U','C')-psyrk('U','C')| = 0
  |syrk('L','N')-psyrk('L','N')| = 0
  |syrk('L','T')-psyrk('L','T')| = 0
  |syrk('L','H')-psyrk('L','H')| = 0
  |syrk('L','C')-psyrk('L','C')| = 0

Go back to Summary of /test programs.