doc/html/test_ptrsm2.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/frobenius.h>
 #include <myramath/dense/gemm.h>
 #include <myramath/dense/tril.h>
 #include <myramath/dense/triu.h>
 #include <myramath/dense/trsm.h>
 #include <myramath/dense/herk.h>
 #include <myramath/dense/potrf.h>

 // Parallel algorithms.
 #include <myramath/pdense/ptrsm.h>
 #include <myramath/pdense/pgemm.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 well-conditioned L (a cholesky triangle).
   auto G = Matrix<Number>::random(I,I);
   auto L = herk(G,'N');
   potrf_inplace(L);
   Number one(1);
   auto alpha = random<Number>();
   // Initialize options.
   auto options = Options::create().set_nthreads(4).set_blocksize(64);
   // Try all variations of side/op.
   std::vector<char> sides;
   sides.push_back('L');
   sides.push_back('R');
   std::vector<char> ops;
   ops.push_back('N');
   ops.push_back('T');
   ops.push_back('H');
   ops.push_back('C');
   for (int s = 0; s < sides.size(); ++s)
     for (int o = 0; o < ops.size(); ++o)
       {
       char side = sides[s];
       char op = ops[o];
       // Generate random X/B
       auto X = (side == 'L') ? Matrix<Number>::random(I,J) : Matrix<Number>::random(J,I);
       auto B = (side == 'L') ? (one/alpha)*pgemm(L.make_Matrix(),op,X) : (one/alpha)*pgemm(X,L.make_Matrix(),op);
       // Backsolve using both trsm() and ptrsm()
       auto B_serial = B;
       auto B_parallel = B;
       trsm_inplace(side,op,L,B_serial,'N',alpha);
       ptrsm_inplace(side,op,L,B_parallel,'N',alpha,options);
       // Compare errors.
       Precision e_serial = frobenius(B_serial-X) / frobenius(X);
       Precision e_parallel = frobenius(B_parallel-X) / frobenius(X);
       if (side == 'L')
         {
         myra::out() << "  |L^" << op << "\\B-X| serial = " << e_serial << std::endl;
         myra::out() << "  |L^" << op << "\\B-X| parallel = " << e_parallel << std::endl;
         }
       else if (side == 'R')
         {
         myra::out() << "  |B/L^" << op << "-X| serial = " << e_serial << std::endl;
         myra::out() << "  |B/L^" << op << "-X| parallel = " << e_parallel << std::endl;
         }
       REQUIRE(e_serial < tolerance);
       REQUIRE(e_parallel < tolerance);
       }
   }

 } // namespace

 ADD_TEST("ptrsm2","[pdense][parallel]")
   {
   int I = 256;
   int J = 128;
   test<NumberS>(I,J,1.0e-3f);
   test<NumberD>(I,J,1.0e-8);
   test<NumberC>(I,J,1.0e-3f);
   test<NumberZ>(I,J,1.0e-8);
   }
potrf.h
Cholesky factorization routines for positive definite matrices.

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

myra::Matrix
Tabulates an IxJ matrix. Allows random access, has column major layout to be compatible with BLAS/LAP...
Definition: bdsqr.h:20

herk.h
Routines for hermitian rank-k updates, a specialized form of Matrix*Matrix multiplication.

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

ptrsm.h
Thread-parallel version of dense/trsm.h, triangular Matrix \ dense Matrix backsolution.

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

myra
Definition: syntax.dox:1

trsm.h
Routines for backsolving by a triangular Matrix or LowerMatrix.

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

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.

pgemm.h
Thread-parallel version of dense/gemm.h, Matrix*Matrix multiplication.

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