doc/html/test_pgetrf_tile.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/intRange.h>

 // Serial algorithms.
 #include <myramath/dense/getrf.h>
 #include <myramath/dense/trsm.h>
 #include <myramath/dense/gemm.h>
 #include <myramath/dense/frobenius.h>
 #include <myramath/dense/swaps.h>

 // Parallel algorithms.
 #include <myramath/pdense/pgemm.h>
 #include <myramath/pdense/pgetrf.h>
 #include <myramath/pdense/ptrsm.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;
   // Construct random matrix and right hand side.
   auto A = Matrix<Number>::random(I,I);
   auto B = Matrix<Number>::random(I,J);
   Number one(1);
   // Initialize options.
   auto options = Options::create().set_nthreads(4).set_blocksize(128);
   // Measure factor/solve times for serial routines.
   auto A_serial = A;
   auto X_serial = B;
   auto P_serial = getrf_inplace(A_serial);
   swap_rows(P_serial,X_serial);                              // solve by P
   trsm_inplace('L', 'L', 'N', A_serial, X_serial, 'U', one); // solve by L
   trsm_inplace('L', 'U', 'N', A_serial, X_serial, 'N', one); // solve by U
   Precision e_serial = frobenius(gemm(A,X_serial)-B) / frobenius(B);
   // Measure factor/solve times for parallel routines.
   auto A_parallel = A;
   auto X_parallel = B;
   auto P_parallel = pgetrf_tile(A_parallel,options);
   swap_rows(P_parallel,X_parallel);                                        // solve by P
   ptrsm_inplace('L', 'L', 'N', A_parallel, X_parallel, 'U', one, options); // solve by L
   ptrsm_inplace('L', 'U', 'N', A_parallel, X_parallel, 'N', one, options); // solve by U
   Precision e_parallel = frobenius(gemm(A,X_parallel)-B) / frobenius(B);
   // Report accuracy and time.
   myra::out() << "  |U\\(L\\B)-X|, serial = " << e_serial << std::endl;
   myra::out() << "  |U\\(L\\B)-X|, parallel = " << e_parallel << std::endl;
   REQUIRE(e_serial < tolerance);
   REQUIRE(e_parallel < tolerance);
   }

 } // namespace

 ADD_TEST("pgetrf_tile","[pdense][parallel]")
   {
   int I = 512;
   int J = 256;
   test<NumberD> (I,J,1.0e-8);
   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

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

myra
Definition: syntax.dox:1

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

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

swaps.h
Routines related to swap sequences, often used during pivoting.

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

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.

getrf.h
General purpose A = P&#39;*L*U decomposition for square Matrix&#39;s.

pgetrf.h
Thread-parallel versions of dense/getrf.h, LU decomposition of a Matrix.

myra::pgetrf_tile
std::vector< int > pgetrf_tile(const MatrixRange< NumberS > &A, pdense::Options options=pdense::Options::create())
Overwrites A with its P&#39;*L*U factorization, returns pivoting data P_swaps.
Definition: pgetrf_tile.cpp:213

intRange.h
Interface class for representing subranges of contiguous int&#39;s.