doc/html/test_psymm2.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/dense/LowerMatrix.h>
 #include <myramath/dense/LowerMatrixRange.h>

 // Serial algorithms.
 #include <myramath/utility/random.h>
 #include <myramath/dense/transpose.h>
 #include <myramath/dense/tril.h>
 #include <myramath/dense/triu.h>
 #include <myramath/dense/symm.h>
 #include <myramath/dense/frobenius.h>

 // Parallel algorithms.
 #include <myramath/pdense/psymm.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;
   // Make random symmetric matrix A.
   auto A = Matrix<Number>::random(I,I);
   A = A + transpose(A);
   Number alpha = random<Number>();
   Number beta  = random<Number>();
   // Grab A's lower triangle into L.
   LowerMatrix<Number> L(A);
   // Initialize options.
   auto options = Options::create().set_nthreads(4).set_blocksize(128);
   // Check psymm('L'eft)
     {
     auto B = Matrix<Number>::random(I,J);
     auto C1 = Matrix<Number>::random(I,J);
     auto C2 = C1;
     symm_inplace('L', C1, L, B, alpha, beta);
     psymm_inplace('L', C2, L, B, alpha, beta, options);
     Precision error = frobenius(C1-C2)/frobenius(C1);
     myra::out() << "  |symm('L')-psymm('L')| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   // Check psymm('R'ight)
     {
     auto B = Matrix<Number>::random(J,I);
     auto C1 = Matrix<Number>::random(J,I);
     auto C2 = C1;
     symm_inplace('R', C1, L, B, alpha, beta);
     psymm_inplace('R', C2, L, B, alpha, beta, options);
     Precision error = frobenius(C1-C2)/frobenius(C1);
     myra::out() << "  |symm('R')-psymm('R')| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   }

 } // namespace

 ADD_TEST("psymm2","[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);
   }
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

myra::pdense::Options
Options pack for routines in /pdense.
Definition: Options.h:24

LowerMatrixRange.h
Range construct for a lower triangular matrix stored in rectangular packed format.

myra
Definition: syntax.dox:1

LowerMatrix.h
Specialized container for a lower triangular matrix, O(N^2/2) storage. Used by symmetry exploiting ma...

transpose.h
Returns a transposed copy of a Matrix. The inplace version only works on a square operand...

tril.h
Returns the lower triangle of a dense Matrix.

triu.h
Returns the upper triangle of a dense Matrix.

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

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

Options.h
Options pack for routines in /pdense.

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

random.h
Simplistic random number functions.

myra::LowerMatrix
Stores a lower triangular matrix in rectangular packed format.
Definition: conjugate.h:22

symm.h
Routines for symmetric Matrix * dense Matrix multiplication.

psymm.h
Thread-parallel symmetric Matrix * dense Matrix multiplication.