doc/html/test_rldlt2_saddle2.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/Vector.h>
 #include <myramath/dense/VectorRange.h>
 #include <myramath/sparse/Pattern.h>
 #include <myramath/sparse/PatternRange.h>
 #include <myramath/sparse/PatternBuilder.h>
 #include <myramath/sparse/SparseMatrix.h>
 #include <myramath/sparse/SparseMatrixRange.h>
 #include <myramath/sparse/Permutation.h>

 // Algorithms.
 #include <myramath/dense/euclidean.h>
 #include <myramath/sparse/gemv.h>

 // Solver under test.
 #include <myramath/multifrontal/rldlt/SparseRLDLTSolver.h>

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

 using namespace myra;

 namespace detail {

 template<class Precision>
 void test_saddle2(int N, Precision tolerance)
   {
   // Generate a system with saddle point structure, a block diagonal
   // system with [1 0; 0 1] blocks.
   PatternBuilder P(2*N,2*N);
   for (int n = 0; n < N; ++n)
     {
     P.insert(2*n+1,2*n);
     P.insert(2*n,2*n+1);
     }
   auto A = SparseMatrix<Precision>::fill(P.make_Pattern(),1);
   auto perm = Permutation::random(2*N);
   myra::out() << "A.pattern() = " << A.pattern() << std::endl;

   typedef multifrontal::Options Options;
   Options options = Options::create().set_blocksize(1).set_globsize(1).set_nthreads(1);
   SparseRLDLTSolver<Precision> solver(A,perm,options);

   // Check A*x = b solution.
   auto b = Vector<Precision>::random(2*N);
   auto x = b;
   solver.solve(x.column());
   Precision error = euclidean( gemv(A,x) - b );
   myra::out() << "|A*x-b| = " << error << std::endl;
   REQUIRE( error < tolerance );
   }

 } // namespace detail

 ADD_TEST("rldlt2_saddle2","[multifrontal]")
   {
   ::detail::test_saddle2<float >(20,1.0e-4f);
   ::detail::test_saddle2<double>(20,1.0e-10);
   }
euclidean.h
Routines for computing euclidean norm of a Vector/VectorRange, or normalizing a Vector/VectorRange to...

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

VectorRange.h
Interface class for representing subranges of dense Vector&#39;s.

myra::SparseMatrix::fill
static SparseMatrix< Number > fill(const PatternRange &P, Number c)
Generates a SparseMatrix with Pattern P, filled with constant c.
Definition: SparseMatrix.cpp:521

PatternBuilder.h
Convenience type for building Pattern&#39;s, uses coordinate/couplet format. Note that PatternBuilder may...

myra::SparseRLDLTSolver
Sparse direct solver suitable for real symmetric indefinite systems.
Definition: SparseRLDLTSolver.h:61

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

myra::Vector::random
static Vector< Number > random(int N)
Generates a random Vector of specified size.
Definition: Vector.cpp:276

myra
Definition: syntax.dox:1

detail
Definition: random.cpp:45

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

gemv.h
Signatures for sparse matrix * dense vector multiplies. All delegate to gemm() under the hood...

myra::SparseMatrix::pattern
PatternRange pattern() const
Returns the nonzero Pattern over all of A(:,:)
Definition: SparseMatrix.cpp:221

PatternRange.h
Range/Iterator types associated with Pattern.

Vector.h
Container for either a column vector or row vector (depends upon the usage context) ...

myra::PatternBuilder
Like Pattern, but easier to populate via insert()/erase() methods.
Definition: PatternBuilder.h:51

Pattern.h
Container class for a sparse nonzero pattern, used in reordering/symbolic analysis.

Permutation.h
Aggregates a (perm, iperm, swaps) triple into a vocabulary type.

myra::Permutation::random
static Permutation random(int N)
Generates a random Matrix of specified size.
Definition: Permutation.cpp:188

SparseRLDLTSolver.h
Sparse direct solver suitable for real symmetric indefinite systems.

SparseMatrixRange.h
Range/Iterator types associated with SparseMatrix.