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

 // Algorithms.
 #include <myramath/utility/random.h>
 #include <myramath/dense/gemm.h>
 #include <myramath/dense/syr2k.h>
 #include <myramath/dense/frobenius.h>
 #include <myramath/dense/transpose.h>
 #include <myramath/dense/hermitian.h>
 #include <myramath/dense/conjugate.h>
 #include <myramath/dense/tril.h>
 #include <myramath/dense/triu.h>

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

 using namespace myra;

 namespace {

 template<class Number> void test(int I, int J, typename ReflectPrecision<Number>::type tolerance)
   {
   // Useful typedef.
   typedef typename ReflectPrecision<Number>::type Precision;
   myra::out() << typestring<Number>() << std::endl;
   // Make random nonsquare matrix A and B.
   auto A = Matrix<Number>::random(I,J);
   auto B = Matrix<Number>::random(I,J);
   // Compare syr2k(A,'N') to gemm(A,'N',B,'T')+gemm(B,'N',A,'T')
     {
     LowerMatrix<Number> C1(gemm(A,'N',B,'T')+gemm(B,'N',A,'T'));
     LowerMatrix<Number> C2 = syr2k(A,B,'N');
     Precision error = frobenius(C2-C1);
     myra::out() << "  |syr2k('N')-gemm('N','T')| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   // Compare syr2k(A,'T') to gemm(A,'T',B,'N')+gemm(B,'T',A,'N')
     {
     LowerMatrix<Number> C1(gemm(A,'T',B,'N')+gemm(B,'T',A,'N'));
     LowerMatrix<Number> C2 = syr2k(A,B,'T');
     Precision error = frobenius(C2-C1);
     myra::out() << "  |syr2k('T')-gemm('T','N')| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   // Compare syr2k(A,'H') to gemm(A,'H',B,'C')+gemm(B,'H',A,'C')
     {
     LowerMatrix<Number> C1(gemm(A,'H',B,'C')+gemm(B,'H',A,'C'));
     LowerMatrix<Number> C2 = syr2k(A,B,'H');
     Precision error = frobenius(C2-C1);
     myra::out() << "  |syr2k('H')-gemm('H','C')| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   // Compare syr2k(A,'C') to gemm(A,'C',B,'H')+gemm(B,'C',A,'H')
     {
     LowerMatrix<Number> C1(gemm(A,'C',B,'H')+gemm(B,'C',A,'H'));
     LowerMatrix<Number> C2 = syr2k(A,B,'C');
     Precision error = frobenius(C2-C1);
     myra::out() << "  |syr2k('C')-gemm('C','H')| = " << error << std::endl;
     REQUIRE(error < tolerance);
     }
   }

 } // namespace

 ADD_TEST("ssyr2kLower","[dense][blas]")
   { test<NumberS>(57,24,1.0e-4f); }

 ADD_TEST("dsyr2kLower","[dense][blas]")
   { test<NumberD>(57,24,1.0e-8); }

 ADD_TEST("csyr2kLower","[dense][blas]")
   { test<NumberC>(57,24,1.0e-4f); }

 ADD_TEST("zhsy2kLower","[dense][blas]")
   { test<NumberZ>(57,24,1.0e-8); }

conjugate.h
Returns a conjugated copy of a Matrix or Vector. Or, conjugate one inplace.

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

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.

syr2k.h
Routines for symmetric rank-2k updates, a specialized form of Matrix*Matrix multiplication.

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

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

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

random.h
Simplistic random number functions.

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

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