doc/html/test_multiply.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/sparse/PatternRange.h>
 #include <myramath/sparse/SparseMatrix.h>
 #include <myramath/sparse/SparseMatrixRange.h>
 #include <myramath/dense/Matrix.h>
 #include <myramath/dense/MatrixRange.h>

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

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

 using namespace myra;

 namespace {

 // Tests multiply(A) = A'A
 template<class Number> void test1(int Ai, int Aj, int An, typename ReflectPrecision<Number>::type tolerance)
   {
   myra::out() << typestring<Number>() << std::endl;
   typedef typename ReflectPrecision<Number>::type Precision;
   auto A = SparseMatrix<Number>::random(Ai,Aj,An);
   auto C1 = multiply(A);
   auto C2 = gemm(A.make_Matrix(),'H',A.make_Matrix());
   Precision error = frobenius(C1.make_Matrix()-C2)/frobenius(C2);
   myra::out() << "|A'A(sparse) - A'A(dense)| = " << error << std::endl;
   myra::out() << C1.pattern() << std::endl;
   REQUIRE(error < tolerance);
   }

 // Tests multiply(A,B) = A'B
 template<class Number> void test2(int Ai, int Aj, int An, int Bi, int Bj, int Bn, typename ReflectPrecision<Number>::type tolerance)
   {
   myra::out() << typestring<Number>() << std::endl;
   typedef typename ReflectPrecision<Number>::type Precision;
   auto A = SparseMatrix<Number>::random(Ai,Aj,An);
   auto B = SparseMatrix<Number>::random(Bi,Bj,Bn);
   auto C1 = multiply(A,B);
   auto C2 = gemm(A.make_Matrix(),'H',B.make_Matrix());
   Precision error = frobenius(C1.make_Matrix()-C2)/frobenius(C2);
   myra::out() << "|A'B(sparse) - A'B(dense)| = " << error << std::endl;
   myra::out() << C1.pattern() << std::endl;
   REQUIRE(error < tolerance);
   }

 } // namespace

 ADD_TEST("multiply","[sparse]")
   {
   // Test multiply(A)
   int Ai = 20;
   int Aj = 10;
   int An = 35;
   test1<NumberS>(Ai,Aj,An,1.0e-4f);
   test1<NumberD>(Ai,Aj,An,1.0e-10);
   test1<NumberC>(Ai,Aj,An,1.0e-4f);
   test1<NumberZ>(Ai,Aj,An,1.0e-10);
   // Test multiply(A,B)
   int Bi = Ai;
   int Bj = 15;
   int Bn = 25;
   test2<NumberS>(Ai,Aj,An,Bi,Bj,Bn,1.0e-4f);
   test2<NumberD>(Ai,Aj,An,Bi,Bj,Bn,1.0e-10);
   test2<NumberC>(Ai,Aj,An,Bi,Bj,Bn,1.0e-4f);
   test2<NumberZ>(Ai,Aj,An,Bi,Bj,Bn,1.0e-10);
   }
multiply.h
Routines to multiply "fat inner products" of SparseMatrix&#39;s, C = A&#39;A and C = A&#39;B. ...

MatrixRange.h
Interface class for representing subranges of dense Matrix&#39;s.

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

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

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

PatternRange.h
Range/Iterator types associated with Pattern.

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

gemm.h
Variety of routines all for dense Matrix*Matrix multiplies. Delegates to the BLAS.

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.