cgemmC

Source: tests/dense/gemm.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>

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

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

using namespace myra;

namespace {

// Note that the native BLAS does not support just 'C'onjugating a complex argument, 
// so we have a few tests for it. There's currently no other tests for GEMM, since 
// it's so well covered by other tests.
template<class Precision> void test(int I, int J, int K, Precision tolerance)
  {
  typedef std::complex<Precision> Number;
  myra::out() << typestring<Number>() << std::endl;

  Number alpha = random<Number>();
  Number beta  = random<Number>();

  // Test gemm('C','N')
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(I,K);
    auto B = Matrix<Number>::random(K,J);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'C',B,'N',alpha,beta);
    Precision error = frobenius(beta*C+alpha*conjugate(A)*B-D);
    myra::out() << "  |gemm('C','N')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  
  // Test gemm('C','T')
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(I,K);
    auto B = Matrix<Number>::random(J,K);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'C',B,'T',alpha,beta);
    Precision error = frobenius(beta*C+alpha*conjugate(A)*transpose(B)-D);
    myra::out() << "  |gemm('C','T')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }

  // Test gemm('C','H')
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(I,K);
    auto B = Matrix<Number>::random(J,K);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'C',B,'H',alpha,beta);
    Precision error = frobenius(beta*C+alpha*conjugate(A)*hermitian(B)-D);
    myra::out() << "  |gemm('C','H')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }

  // Test gemm('N','C')
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(I,K);
    auto B = Matrix<Number>::random(K,J);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'N',B,'C',alpha,beta);
    Precision error = frobenius(beta*C+alpha*A*conjugate(B)-D);
    myra::out() << "  |gemm('N','C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }

  // Test gemm('T','C')
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(K,I);
    auto B = Matrix<Number>::random(K,J);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'T',B,'C',alpha,beta);
    Precision error = frobenius(beta*C+alpha*transpose(A)*conjugate(B)-D);
    myra::out() << "  |gemm('T','C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }

  // Test gemm('H','C')
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(K,I);
    auto B = Matrix<Number>::random(K,J);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'H',B,'C',alpha,beta);
    Precision error = frobenius(beta*C+alpha*hermitian(A)*conjugate(B)-D);
    myra::out() << "  |gemm('H','C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }

  // Test gemm('C','C')  
    {
    auto C = Matrix<Number>::random(I,J);
    auto A = Matrix<Number>::random(I,K);
    auto B = Matrix<Number>::random(K,J);
    Matrix<Number> D = C;
    gemm_inplace(D,A,'C',B,'C',alpha,beta);
    Precision error = frobenius(beta*C+alpha*conjugate(A)*conjugate(B)-D);
    myra::out() << "  |gemm('C','C')| = " << error << std::endl;
    REQUIRE(error < tolerance);
    }
  
  }

} // namespace

ADD_TEST("cgemmC","[dense][blas]")
  { test<NumberS> (20,12,17,1.0e-4f); }
  
ADD_TEST("zgemmC","[dense][blas]")
  { test<NumberD> (20,12,17,1.0e-10); }

Results: [PASS]

std::complex<float>
  |gemm('C','N')| = 5.28042e-06
  |gemm('C','T')| = 2.97628e-06
  |gemm('C','H')| = 3.02914e-06
  |gemm('N','C')| = 5.20144e-06
  |gemm('T','C')| = 2.79814e-06
  |gemm('H','C')| = 2.62966e-06
  |gemm('C','C')| = 2.94807e-06

Go back to Summary of /test programs.