doc/html/test_sparse_hemm.html

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

 // Algorithms.
 #include <myramath/dense/hemm.h>
 #include <myramath/sparse/hemm.h>
 #include <myramath/dense/frobenius.h>

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

 using namespace myra;

 namespace {

 // Tests hemm('L'eft)
 template<class Number> void test1(int IJ, int N, int K, typename ReflectPrecision<Number>::type tolerance)
   {
   myra::out() << "test1 " << typestring<Number>() << std::endl;
   typedef typename ReflectPrecision<Number>::type Precision;
   auto A = SparseMatrix<Number>::random(IJ,IJ,N);
   // Diagonal must be pure real.
   A.transform_diagonal([](const Number& a){return realpart(a);});
   auto X = Matrix<Number>::random(IJ,K);
   auto B1 = hemm('L','U',A,X);
   auto B2 = hemm('L','U',A.make_Matrix(),X);
   Precision B_error = frobenius(B1-B2);
   auto C1 = hemm('L','L',A,X);
   auto C2 = hemm('L','L',A.make_Matrix(),X);
   Precision C_error = frobenius(C1-C2);
   myra::out() << "  error in hemm('L','U') = " << B_error << std::endl;
   myra::out() << "  error in hemm('L','L') = " << C_error << std::endl;
   REQUIRE(B_error < tolerance);
   REQUIRE(C_error < tolerance);
   }

 // Tests hemm('R'ight)
 template<class Number> void test2(int IJ, int N, int K, typename ReflectPrecision<Number>::type tolerance)
   {
   myra::out() << "test2 " << typestring<Number>() << std::endl;
   typedef typename ReflectPrecision<Number>::type Precision;
   auto A = SparseMatrix<Number>::random(IJ,IJ,N);
   // Diagonal must be pure real.
   A.transform_diagonal([](const Number& a){return realpart(a);});
   auto X = Matrix<Number>::random(K,IJ);
   auto B1 = hemm('R','U',A,X);
   auto B2 = hemm('R','U',A.make_Matrix(),X);
   Precision B_error = frobenius(B1-B2);
   auto C1 = hemm('R','L',A,X);
   auto C2 = hemm('R','L',A.make_Matrix(),X);
   Precision C_error = frobenius(C1-C2);
   myra::out() << "  error in hemm('R','U') = " << B_error << std::endl;
   myra::out() << "  error in hemm('R','L') = " << C_error << std::endl;
   REQUIRE(B_error < tolerance);
   REQUIRE(C_error < tolerance);
   }

 } // namespace

 ADD_TEST("sparse_hemm","[sparse]")
   {
   // Test hemm('L',...)
   test1<NumberS>(15,40,8,1.0e-4f);
   test1<NumberD>(15,40,8,1.0e-9);
   test1<NumberC>(15,40,8,1.0e-4f);
   test1<NumberZ>(15,40,8,1.0e-9);
   // Test hemm('R',...)
   test2<NumberS>(15,40,8,1.0e-4f);
   test2<NumberD>(15,40,8,1.0e-9);
   test2<NumberC>(15,40,8,1.0e-4f);
   test2<NumberZ>(15,40,8,1.0e-9);
   }
MatrixRange.h
Interface class for representing subranges of dense Matrix&#39;s.

frobenius.h
Routines for computing Frobenius norms of various algebraic containers.

myra::Matrix::random
static Matrix< Number > random(int I, int J)
Generates a random Matrix of specified size.
Definition: Matrix.cpp:353

hemm.h
Routines for hermitian Matrix * dense Matrix multiplication.

myra::SparseMatrix::random
static SparseMatrix< Number > random(int I, int J, int N)
Generates a random SparseMatrix with size IxJ and (approximately) N nonzeros.
Definition: SparseMatrix.cpp:493

SparseMatrix.h
General purpose compressed-sparse-column (CSC) container.

myra
Definition: syntax.dox:1

Number.h
Various utility functions/classes related to scalar Number types.

hemm.h
Routines for hermitian SparseMatrix * dense Matrix multiplication.

Matrix.h
General purpose dense matrix container, O(i*j) storage.

myra::ReflectPrecision
Reflects Precision trait for a Number, scalar Number types should specialize it.
Definition: Number.h:33

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.