dense_io1

Source: tests/dense/io1.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.      //
// ========================================================================= //

// Container types.
#include <myramath/utility/Number.h>
#include <myramath/dense/Matrix.h>
#include <myramath/dense/Vector.h>
#include <myramath/dense/LowerMatrix.h>
#include <myramath/dense/DiagonalMatrix.h>

// Algorithms.
#include <myramath/dense/frobenius.h>

// Serialization backend.
#include <myramath/io/VectorStream.h>

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

using namespace myra;

namespace {

template<class Number> void roundtrip_Matrix()
  {
  // Make original.
  auto A1 = Matrix<Number>::random(5,7);
  // Write it out, read back into a copy.
  VectorStream inout;
  A1.write(inout);
  Matrix<Number> A2(inout);
  // Check errors.
  auto error = frobenius(A1-A2);
  myra::out() << "|A1-A2| = " << error << " (" << typestring<Number>() << ")" << std::endl;
  REQUIRE(error == 0);
  }

template<class Number> void roundtrip_LowerMatrix()
  {
  // Make original.
  auto L1 = LowerMatrix<Number>::random(5);
  // Write it out, read back into a copy.
  VectorStream inout;
  L1.write(inout);
  LowerMatrix<Number> L2(inout);  
  // Check errors.
  auto error = frobenius(L1-L2);
  myra::out() << "|L1-L2| = " << error << " (" << typestring<Number>() << ")" << std::endl;
  REQUIRE(error == 0);
  }

template<class Number> void roundtrip_DiagonalMatrix()
  {
  // Make original.
  auto D1 = DiagonalMatrix<Number>::random(5);
  // Write it out, read back into a copy.
  VectorStream inout;
  D1.write(inout);
  DiagonalMatrix<Number> D2(inout);
  // Check errors.
  auto error = frobenius(D1-D2);
  myra::out() << "|D1-D2| = " << error << " (" << typestring<Number>() << ")" << std::endl;
  REQUIRE(error == 0);
  }


template<class Number> void roundtrip_Vector()
  {
  // Make original.
  auto V1 = Vector<Number>::random(5);
  // Write it out, read back into a copy.
  VectorStream inout;
  V1.write(inout);
  Vector<Number> V2(inout);
  // Check errors.
  auto error = frobenius(V1-V2);
  myra::out() << "|V1-V2| = " << error << " (" << typestring<Number>() << ")" << std::endl;
  REQUIRE(error == 0);
  }

} // namespace

ADD_TEST("dense_io1","[dense]")
  {
  // Test serialization for Matrix<>
  roundtrip_Matrix<NumberS> ();
  roundtrip_Matrix<NumberD> ();
  roundtrip_Matrix<NumberC> ();
  roundtrip_Matrix<NumberZ> ();
  // Test serialization for LowerMatrix<>
  roundtrip_LowerMatrix<NumberS> ();
  roundtrip_LowerMatrix<NumberD> ();
  roundtrip_LowerMatrix<NumberC> ();
  roundtrip_LowerMatrix<NumberZ> ();
  // Test serialization for DiagonalMatrix<>
  roundtrip_DiagonalMatrix<NumberS> ();
  roundtrip_DiagonalMatrix<NumberD> ();
  roundtrip_DiagonalMatrix<NumberC> ();
  roundtrip_DiagonalMatrix<NumberZ> ();
  // Test serialization for Vector<>
  roundtrip_Vector<NumberS> ();
  roundtrip_Vector<NumberD> ();
  roundtrip_Vector<NumberC> ();
  roundtrip_Vector<NumberZ> ();
  }

Results: [PASS]

|A1-A2| = 0 (float)
|A1-A2| = 0 (double)
|A1-A2| = 0 (std::complex<float>)
|A1-A2| = 0 (std::complex<double>)
|L1-L2| = 0 (float)
|L1-L2| = 0 (double)
|L1-L2| = 0 (std::complex<float>)
|L1-L2| = 0 (std::complex<double>)
|D1-D2| = 0 (float)
|D1-D2| = 0 (double)
|D1-D2| = 0 (std::complex<float>)
|D1-D2| = 0 (std::complex<double>)
|V1-V2| = 0 (float)
|V1-V2| = 0 (double)
|V1-V2| = 0 (std::complex<float>)
|V1-V2| = 0 (std::complex<double>)

Go back to Summary of /test programs.