Ticket #10045: test_symmetric_matrix_serialization.cpp

// Test cases for supporting serialization in boost::numeric::ublas::symmetrix_matrix.
// =====================================================================
// In response to https://svn.boost.org/trac/boost/ticket/10045


// Author
// ==============
// Shivam Mittal
// Email - 2015csb1032@iitrpr.ac.in
// Github profile - github.com/shivam5
// Date - 2nd April 2017


// Should be placed in ublas/test/

// Compiling 
// ==========

 // g++ -I <path to modular_boost> test_symmetric_matrix_serialization.cpp -L<path to installed libraries (stage/lib)> -static -lboost_serialization

 // Example (my computer):
 // g++ -I /home/shivam/Desktop/boost/modular_boost/ test_symmetric_matrix_serialization.cpp -L/home/shivam/Desktop/boost/modular_boost/stage/lib -static -lboost_serialization

// Running
// ==========
// ./a.out


#include <boost/numeric/ublas/io.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
#include <iostream>
#include <fstream>
#include <string>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include "common/testhelper.hpp"
#include "utils.hpp"

using namespace boost::numeric::ublas;

#define N 200

template <typename T, typename U>
void save_smatrix(const symmetric_matrix<T,U> &s, const char * filename){
    std::ofstream ofs(filename);
    boost::archive::text_oarchive oa(ofs);
    oa << s;
}

template <typename T, typename U>
void load_smatrix(symmetric_matrix<T,U> &s, const char * filename){
    std::ifstream ifs(filename);
    boost::archive::text_iarchive ia(ifs);
    ia >> s;
}


template <class T>
bool check(int size = 3) {
    bool pass = true;

    std::string filename = "filename";

    symmetric_matrix<T, lower> ml (size, size);
    symmetric_matrix<T, upper> mu (size, size);
    symmetric_matrix<T, lower> ml2 (size, size);
    symmetric_matrix<T, upper> mu2 (size, size);

    for (unsigned i = 0; i < ml.size1 (); ++ i)
        for (unsigned j = 0; j <= i; ++ j)
            ml (i, j) = (size * i + j);

    for (unsigned i = 0; i < mu.size1 (); ++ i)
        for (unsigned j = i; j < mu.size2 (); ++ j)
            mu (i, j) = (size * i + j);


    save_smatrix <T, lower> (ml, filename.c_str());
    load_smatrix <T, lower>(ml2, filename.c_str());
    pass &= compare(ml, ml2);

    save_smatrix <T, upper> (mu, filename.c_str());
    load_smatrix <T, upper>(mu2, filename.c_str());
    pass &= compare(mu, mu2);


    for (unsigned i = 0; i < ml.size1 (); ++ i)
        for (unsigned j = 0; j <= i; ++ j)
            ml (i, j) = j * i + j;

    for (unsigned i = 0; i < mu.size1 (); ++ i)
        for (unsigned j = i; j < mu.size2 (); ++ j)
            mu (i, j) = (j+i) * i + j;


    save_smatrix <T, lower> (ml, filename.c_str());
    load_smatrix <T, lower>(ml2, filename.c_str());
    pass &= compare(ml, ml2);

    save_smatrix <T, upper> (mu, filename.c_str());
    load_smatrix <T, upper>(mu2, filename.c_str());
    pass &= compare(mu, mu2);


    return pass;
}


BOOST_UBLAS_TEST_DEF (check_mat_int) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in integer symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<int> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_uint) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in unsigned integer symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<unsigned int> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_long) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in long symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<long> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_ulong) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in unsigned integer symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<unsigned long> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_float) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in float symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<float> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_double) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in double symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<double> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_size_t) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in size_t symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<size_t> (i));
}

BOOST_UBLAS_TEST_DEF (check_mat_char) {
    BOOST_UBLAS_DEBUG_TRACE( "Checking serialization in char symmetric matrices" );
    for (int i=1; i<N; i++)
            BOOST_UBLAS_TEST_CHECK(check<char> (i));
}


int main () {
    BOOST_UBLAS_TEST_BEGIN();

    BOOST_UBLAS_TEST_DO( check_mat_int );
    BOOST_UBLAS_TEST_DO( check_mat_uint );
    BOOST_UBLAS_TEST_DO( check_mat_long );
    BOOST_UBLAS_TEST_DO( check_mat_ulong );
    BOOST_UBLAS_TEST_DO( check_mat_float );
    BOOST_UBLAS_TEST_DO( check_mat_double );
    BOOST_UBLAS_TEST_DO( check_mat_size_t );
    BOOST_UBLAS_TEST_DO( check_mat_char );

    BOOST_UBLAS_TEST_END();

    return EXIT_SUCCESS;
}