zMatrix22

Source: tests/dense/Matrix22.cpp

// ========================================================================= //
// 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/Matrix22.h>
#include <myramath/dense/MatrixRange.h>
#include <myramath/dense/gemm.h>
#include <myramath/dense/frobenius.h>

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

using namespace myra;

namespace {

// Form random A, then its inverse Z, and verify A*Z=I
template<class Number> void test1(typename ReflectPrecision<Number>::type tolerance) 
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto A = Matrix22<Number>::random();
  auto Z = inverse(A);
  auto I = Matrix22<Number>::identity();
  Precision error = frobenius(A*Z-I) / frobenius(A);
  myra::out() << "|A*Z-I|/|A| = " << error << std::endl;
  REQUIRE( error < tolerance );
  }

// Compare gemm_inplace(Matrix22, Matrix) to reference gemm()
template<class Number> void test2(typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto A = Matrix22<Number>::random();
  auto B0 = Matrix<Number>::random(2,25);
  auto B1 = gemm(A,B0);
  gemm_inplace(A,B0);
  Precision error = frobenius(B0-B1)/frobenius(B1);
  myra::out() << "|B0-B1|/|B1| = " << error << std::endl;
  REQUIRE( error < tolerance );
  }

// Compare gemm_inplace(Matrix, Matrix22) to reference gemm()
template<class Number> void test3(typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto B = Matrix22<Number>::random();
  auto A0 = Matrix<Number>::random(25,2);
  auto A1 = gemm(A0,B);
  gemm_inplace(A0,B);
  Precision error = frobenius(A0-A1)/frobenius(A1);
  myra::out() << "|A0-A1|/|A1| = " << error << std::endl;
  REQUIRE( error < tolerance );
  }

} // namespace

ADD_TEST("sMatrix22","[dense][lapack]")
  { 
  test1<NumberS>(1.0e-5f);
  test2<NumberS>(1.0e-5f);
  test3<NumberS>(1.0e-5f);
  }
  
ADD_TEST("dMatrix22","[dense][lapack]")
  { 
  test1<NumberD>(1.0e-10);
  test2<NumberD>(1.0e-10); 
  test3<NumberD>(1.0e-10); 
  }

ADD_TEST("cMatrix22","[dense][lapack]")
  { 
  test1<NumberS>(1.0e-5f);
  test2<NumberS>(1.0e-5f);
  test3<NumberS>(1.0e-5f);
  }

ADD_TEST("zMatrix22","[dense][lapack]")
  { 
  test1<NumberZ>(1.0e-10);
  test2<NumberZ>(1.0e-10); 
  test3<NumberZ>(1.0e-10);  
  }

Results: [PASS]

|A*Z-I|/|A| = 1.54838e-16
|B0-B1|/|B1| = 8.75993e-17
|A0-A1|/|A1| = 1.07422e-16

Go back to Summary of /test programs.