#include <iostream>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/foreach.hpp>

#include "matrix_vector.hpp"

namespace ublas = boost::numeric::ublas;


void test_matrix_row_vector()
{
    // Test iterator and reversed iterator
    typedef ublas::matrix<int> matrix_type;
    typedef ublas::matrix_row_vector<matrix_type> matrix_row_vector_type;

    matrix_type matrix(0, 3);
    matrix_row_vector_type row_vector(matrix);

    std::cout << "Test matrix row vector: " << std::endl;

    unsigned counter = 0;
    row_vector.resize(10);

    for (matrix_row_vector_type::iterator iter = row_vector.begin();
         iter != row_vector.end();
         iter++)
    {
        for (unsigned i = 0; i < matrix.size2(); i++)
        {
            (*iter)[i] = counter++;
        }
    }

    std::cout << "Ascending traversal: " << std::endl;
    for (matrix_row_vector_type::const_iterator iter = row_vector.begin();
         iter != row_vector.end();
         iter++)
    {
        std::cout << *iter << "  ";
    }
    std::cout << std::endl;

    std::cout << "Full matrix: " << matrix << std::endl;

    counter = 10;
    for (matrix_row_vector_type::reverse_iterator iter = row_vector.rbegin();
         iter != row_vector.rend();
         iter++)
    {
        for (unsigned i = 0; i < matrix.size2(); i++)
        {
            (*iter)[i] = counter++;
        }
    }

    std::cout << "Descending traversal: " << std::endl;
    for (matrix_row_vector_type::const_reverse_iterator iter = row_vector.rbegin();
         iter != row_vector.rend();
         iter++)
    {
        std::cout << *iter << "  ";
    }
    std::cout << std::endl;

    std::cout << "Full matrix: " << matrix << std::endl;
}



void test_matrix_column_vector()
{
    // Test iterator and reversed iterator
    typedef ublas::matrix<int> matrix_type;
    typedef ublas::matrix_column_vector<matrix_type> matrix_column_vector_type;

    matrix_type matrix(3, 0);
    matrix_column_vector_type column_vector(matrix);

    std::cout << "Test matrix column vector: " << std::endl;

    unsigned counter = 0;
    column_vector.resize(10);

    for (matrix_column_vector_type::iterator iter = column_vector.begin();
         iter != column_vector.end();
         iter++)
    {
        for (unsigned i = 0; i < matrix.size1(); i++)
        {
            (*iter)[i] = counter++;
        }
    }

    std::cout << "Ascending traversal: " << std::endl;
    for (matrix_column_vector_type::const_iterator iter = column_vector.begin();
         iter != column_vector.end();
         iter++)
    {
        std::cout << *iter << "  ";
    }
    std::cout << std::endl;

    std::cout << "Full matrix: " << matrix << std::endl;

    counter = 10;
    for (matrix_column_vector_type::reverse_iterator iter = column_vector.rbegin();
         iter != column_vector.rend();
         iter++)
    {
        for (unsigned i = 0; i < matrix.size1(); i++)
        {
            (*iter)[i] = counter++;
        }
    }

    std::cout << "Descending traversal: " << std::endl;
    for (matrix_column_vector_type::const_reverse_iterator iter = column_vector.rbegin();
         iter != column_vector.rend();
         iter++)
    {
        std::cout << *iter << "  ";
    }
    std::cout << std::endl;

    std::cout << "Full matrix: " << matrix << std::endl;
}



int main()
{
    test_matrix_row_vector();
    test_matrix_column_vector();

    return 0;
}