diagcat_SparseMatrix

Source: tests/sparse/diagcat.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/Array1.h>
#include <myramath/sparse/SparseMatrix.h>
#include <myramath/sparse/SparseMatrixRange.h>
#include <myramath/sparse/Pattern.h>
#include <myramath/sparse/PatternRange.h>

// Algorithms.
#include <myramath/sparse/diagcat.h>
#include <myramath/sparse/frobenius.h>

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

using namespace myra;

namespace {

// SparseMatrix/SparseMatrixRange

// Test vertcat(A,B)
template<class Number> void test1(typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto A = SparseMatrix<Number>::random(20,20,50);
  auto B = SparseMatrix<Number>::random(10,10,15);  
  auto C = diagcat(A,B);
  Precision error_A = frobenius( C.window(0,20,0,20) - A);
  Precision error_B = frobenius( C.window(20,30,20,30) - B);  
  myra::out() << "  |C.window - A| = " << error_A << std::endl;
  myra::out() << "  |C.window - B| = " << error_B << std::endl;  
  REQUIRE(error_A < tolerance);
  REQUIRE(error_B < tolerance);  
  }

#ifdef MYRAMATH_ENABLE_CPP11

// Test vertcat({A,B,C})
template<class Number> void test2(typename ReflectPrecision<Number>::type tolerance)
  {
  typedef typename ReflectPrecision<Number>::type Precision;
  auto A = SparseMatrix<Number>::random(20,30,50);
  auto B = SparseMatrix<Number>::random(10,20,15);
  auto C = SparseMatrix<Number>::random(15,25,20);  
  auto D = diagcat({A,B,C});
  Precision error_A = frobenius( D.window(0,20,0,30) - A);
  Precision error_B = frobenius( D.window(20,30,30,50) - B);
  Precision error_C = frobenius( D.window(30,45,50,75) - C);
  myra::out() << "  |D.window - A| = " << error_A << std::endl;
  myra::out() << "  |D.window - B| = " << error_B << std::endl;
  myra::out() << "  |D.window - C| = " << error_C << std::endl;
  REQUIRE(error_A < tolerance);
  REQUIRE(error_B < tolerance);
  REQUIRE(error_C < tolerance);
  }

#endif

// Pattern/PatternRange

// Test vertcat(A,B)
void test3()
  {
  auto A = Pattern::random(20,20,50);
  auto B = Pattern::random(10,10,15);  
  auto C = diagcat(A,B);
  bool equal_A = (C.window(0,20,0,20) == A);
  bool equal_B = (C.window(20,30,20,30) == B);  
  myra::out() << "  C.window == A : " << (equal_A?"true":"false") << std::endl;
  myra::out() << "  C.window == B : " << (equal_B?"true":"false") << std::endl;
  REQUIRE(equal_A);
  REQUIRE(equal_B);
  }

#ifdef MYRAMATH_ENABLE_CPP11

// Test vertcat({A,B,C})
void test4()
  {
  auto A = Pattern::random(20,30,50);
  auto B = Pattern::random(10,20,15);
  auto C = Pattern::random(15,25,20);  
  auto D = diagcat({A,B,C});
  bool equal_A = (D.window(0,20,0,30) == A);
  bool equal_B = (D.window(20,30,30,50) == B);
  bool equal_C = (D.window(30,45,50,75) == C);
  myra::out() << "  D.window == A : " << (equal_A?"true":"false") << std::endl;
  myra::out() << "  D.window == B : " << (equal_B?"true":"false") << std::endl;
  myra::out() << "  D.window == C : " << (equal_C?"true":"false") << std::endl;  
  REQUIRE(equal_A);
  REQUIRE(equal_B);
  REQUIRE(equal_C);
  }

#endif

} // namespace

ADD_TEST("diagcat_SparseMatrix","[sparse]")
  {
  test1<NumberS>(1.0e-5f);
  test1<NumberD>(1.0e-10);
  test1<NumberC>(1.0e-5f);  
  test1<NumberZ>(1.0e-10);
  }

#ifdef MYRAMATH_ENABLE_CPP11

ADD_TEST("diagcat_SparseMatrix_cpp11","[sparse]")
  {
  test2<NumberS>(1.0e-5f);
  test2<NumberD>(1.0e-10);
  test2<NumberC>(1.0e-5f);  
  test2<NumberZ>(1.0e-10);
  }

#endif

ADD_TEST("diagcat_Pattern","[sparse]")
  { test3(); }

#ifdef MYRAMATH_ENABLE_CPP11

ADD_TEST("diagcat_Pattern_cpp11","[sparse]")
  { test4(); }

#endif

Results: [PASS]

  |C.window - A| = 0
  |C.window - B| = 0
  |C.window - A| = 0
  |C.window - B| = 0
  |C.window - A| = 0
  |C.window - B| = 0
  |C.window - A| = 0
  |C.window - B| = 0

Go back to Summary of /test programs.