w4kek/WSJT-X
1
0
Fork 0
mirror of https://github.com/saitohirga/WSJT-X.git synced 2025-10-31 04:50:34 -04:00
Code Issues Packages Projects Releases Wiki Activity
WSJT-X/boost/libs/numeric/ublas/test/test_assignment.cpp

781 lines
27 KiB
C++
Raw Blame History

//
// Copyright (c) 2010 Athanasios Iliopoulos
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <boost/numeric/ublas/assignment.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>
#include <boost/numeric/ublas/vector_sparse.hpp>
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/timer.hpp>
#include <ctime>
#include "common/testhelper.hpp"
#include "utils.hpp"
using namespace boost::numeric::ublas;
template <class V>
bool test_vector() {
bool pass = true;
V a(3), ra(3);
a <<= 1, 2, 3;
ra(0) = 1; ra(1) = 2; ra(2) = 3;
pass &= compare_to(a, ra);
V b(7), rb(7);
b<<= a, 10, a;
rb(0) = 1; rb(1) = 2; rb(2) = 3; rb(3)=10, rb(4)= 1; rb(5)=2; rb(6)=3;
pass &= compare_to(b, rb);
{
V c(6), rc(6);
c <<= 1, move(2), 3 ,4, 5, move(-5), 10, 10;
rc(0) = 1; rc(1) = 10; rc(2) = 10; rc(3) = 3; rc(4) = 4; rc(5) = 5;
pass &= compare_to(c, rc);
V d(6), rd(6);
d <<= 1, move_to(3), 3 ,4, 5, move_to(1), 10, 10;
rd(0) = 1; rd(1) = 10; rd(2) = 10; rd(3) = 3; rd(4) = 4; rd(5) = 5;
pass &= compare_to(d, rd);
}
{
V c(6), rc(6);
c <<= 1, move<2>(), 3 ,4, 5, move<-5>(), 10, 10;
rc(0) = 1; rc(1) = 10; rc(2) = 10; rc(3) = 3; rc(4) = 4; rc(5) = 5;
pass &= compare_to(c, rc);
V d(6), rd(6);
d <<= 1, move_to<3>(), 3 ,4, 5, move_to<1>(), 10, 10;
rd(0) = 1; rd(1) = 10; rd(2) = 10; rd(3) = 3; rd(4) = 4; rd(5) = 5;
pass &= compare_to(d, rd);
}
{
V f(6), rf(6);
f <<= 5, 5, 5, 5, 5, 5;
V fa(3); fa<<= 1, 2, 3;
f <<= fill_policy::index_plus_assign(), fa;
rf <<= 6,7,8, 5, 5, 5;
pass &= compare_to(f, rf);
}
{
V f(6), rf(6);
f <<= 5, 5, 5, 5, 5, 5;
V fa(3); fa<<= 1, 2, 3;
f <<= fill_policy::index_minus_assign(), fa;
rf <<= 4,3,2, 5, 5, 5;
pass &= compare_to(f, rf);
}
return pass;
}
template <class V>
bool test_vector_sparse_push_back() {
bool pass = true;
V a(3), ra(3);
a <<= fill_policy::sparse_push_back(), 1, 2, 3;
ra(0) = 1; ra(1) = 2; ra(2) = 3;
pass &= compare_to(a, ra);
V b(7), rb(7);
b<<= fill_policy::sparse_push_back(), a, 10, a;
rb(0) = 1; rb(1) = 2; rb(2) = 3; rb(3)=10, rb(4)= 1; rb(5)=2; rb(6)=3;
pass &= compare_to(b, rb);
V c(6), rc(6);
c <<= fill_policy::sparse_push_back(), 1, move(2), 3 ,4, 5; // Move back (i.e. negative is dangerous for push_back)
rc(0) = 1; rc(1) = 0; rc(2) = 0; rc(3) = 3; rc(4) = 4; rc(5) = 5;
pass &= compare_to(c, rc);
V d(6), rd(6);
d <<= fill_policy::sparse_push_back(), 1, move_to(3), 3 ,4, 5; // Move back (i.e. before current index is dangerous for push_back)
rd(0) = 1; rd(1) = 0; rd(2) = 0; rd(3) = 3; rd(4) = 4; rd(5) = 5;
pass &= compare_to(d, rd);
V e(6), re(6);
e <<= fill_policy::sparse_push_back(), 1, move_to(3), 3 ,4, 5, fill_policy::sparse_insert(), move_to(1), 10, 10; // If you want to move back, use this
re(0) = 1; re(1) = 10; re(2) = 10; re(3) = 3; re(4) = 4; re(5) = 5;
pass &= compare_to(e, re);
return pass;
}
template <class V>
bool test_vector_sparse_insert() {
bool pass = true;
V a(3), ra(3);
a <<= fill_policy::sparse_insert(), 1, 2, 3;
ra(0) = 1; ra(1) = 2; ra(2) = 3;
pass &= compare_to(a, ra);
V b(7), rb(7);
b<<= fill_policy::sparse_insert(), a, 10, a;
rb(0) = 1; rb(1) = 2; rb(2) = 3; rb(3)=10, rb(4)= 1; rb(5)=2; rb(6)=3;
pass &= compare_to(b, rb);
V c(6), rc(6);
c <<= fill_policy::sparse_insert(), 1, move(2), 3 ,4, 5, move(-5), 10, 10; // Move back (i.e. negative is dangerous for sparse)
rc(0) = 1; rc(1) = 10; rc(2) = 10; rc(3) = 3; rc(4) = 4; rc(5) = 5;
pass &= compare_to(c, rc);
V d(6), rd(6);
d <<= fill_policy::sparse_insert(), 1, move_to(3), 3 ,4, 5, move_to(1), 10, 10; // Move back (i.e.before is dangerous for sparse)
rd(0) = 1; rd(1) = 10; rd(2) = 10; rd(3) = 3; rd(4) = 4; rd(5) = 5;
pass &= compare_to(d, rd);
return pass;
}
template <class V>
bool test_matrix() {
bool pass = true;
V A(3,3), RA(3,3);
A <<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
RA(0,0)= 1; RA(0,1)=2; RA(0,2)=3;
RA(1,0)= 4; RA(1,1)=5; RA(1,2)=6;
RA(2,0)= 7; RA(2,1)=8; RA(2,2)=9;
pass &= compare_to(A, RA);
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(3);
b<<= 4,5,6;
B<<= 1, 2, 3, b, 7, project(b, range(1,3));
RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6; // If the first worked we can now probably use it.
pass &= compare_to(B, RB);
}
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(3);
b<<= 4,5,6;
B<<= move(1,0), b, move_to(0,0), 1, 2, 3, move(1,0), 7, project(b, range(1,3));
RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6;
pass &= compare_to(B, RB);
}
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(9);
b<<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
B<<=b;
RB<<=1, 2, 3, 4, 5, 6, 7, 8, 9;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3,
4, 5;
B<<= C,C,
C,C;
RB <<= 2,3,2,3,
4,5,4,5,
2,3,2,3,
4,5,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3, 4, 5;
B<<= C, zero_matrix<typename V::value_type>(2,2),
zero_matrix<typename V::value_type>(2,2), C;
RB<<= 2,3,0,0,
4,5,0,0,
0,0,2,3,
0,0,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3, 4, 5;
B<<= C, zero_matrix<typename V::value_type>(2,2),
zero_matrix<typename V::value_type>(2,2), C;
RB<<= 2,3,0,0,
4,5,0,0,
0,0,2,3,
0,0,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4); // We need that because of the non-zero instatiation of dense types.
V C(2,2);
C <<= 2, 3, 4, 5;
B<<= move(1,1), C;
RB<<= 0,0,0,0,
0,2,3,0,
0,4,5,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<= move_to(0,1), 2, 3, next_row(), 1, 2, next_row(), 4, 5;
RB<<= 0,2,3,0,
1,2,0,0,
4,5,0,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, 6, next_column(), 4, 5;
RB<<= 0,2,4,0,
0,3,5,0,
0,6,0,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, next_row(), traverse_policy::by_row(), 4, 5;
RB<<= 0,2,0,0,
0,3,0,0,
0,0,0,0,
4,5,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8;
RB<<= 0,2,0,0,
0,3,0,0,
4,5,6,7,
8,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8,9, begin1(), 1, 2;
RB<<= 0,2,1,2,
0,3,0,0,
4,5,6,7,
8,9,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = scalar_matrix<typename V::value_type>(4,4,1);
V C(2,2);
C <<= 1, 2, 3, 4;
B<<= fill_policy::index_plus_assign(), move(1,1), C;
RB<<= 1,1,1,1,
1,2,3,1,
1,4,5,1,
1,1,1,1;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = scalar_matrix<typename V::value_type>(4,4,5);
V C(2,2);
C <<= 1, 2, 3, 4;
B<<= fill_policy::index_minus_assign(), move(1,1), C;
RB<<= 5,5,5,5,
5,4,3,5,
5,2,1,5,
5,5,5,5;
pass &= compare_to(B, RB);
}
return pass;
}
template <class V>
bool test_matrix_sparse_push_back() {
bool pass = true;
V A(3,3), RA(3,3);
A <<= fill_policy::sparse_push_back(), 1, 2, 3, 4, 5, 6, 7, 8, 9;
RA(0,0)= 1; RA(0,1)=2; RA(0,2)=3;
RA(1,0)= 4; RA(1,1)=5; RA(1,2)=6;
RA(2,0)= 7; RA(2,1)=8; RA(2,2)=9;
pass &= compare_to(A, RA);
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(3);
b<<= 4,5,6;
B<<=fill_policy::sparse_push_back(), 1, 2, 3, b, 7, project(b, range(1,3));
RB<<= 1, 2, 3, 4, 5, 6, 7, 5, 6; // If the first worked we can now probably use it.
pass &= compare_to(B, RB);
}
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(3);
b<<= 4,5,6;
B<<=fill_policy::sparse_push_back(), move(1,0), b, fill_policy::sparse_insert(), move_to(0,0), 1, 2, 3, move(1,0), 7, project(b, range(1,3));
RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6;
pass &= compare_to(B, RB);
}
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(9);
b<<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
B<<=b;
RB<<=1, 2, 3, 4, 5, 6, 7, 8, 9;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3,
4, 5;
// It might get complicated for sparse push_back, this must go into the tutorial. (This way is not convient nor fast)
B<<=fill_policy::sparse_push_back(), C, move_to(2,2), C, fill_policy::sparse_insert(), move_to(0,2), C, C;
RB <<= 2,3,2,3,
4,5,4,5,
2,3,2,3,
4,5,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3, 4, 5;
B<<=fill_policy::sparse_push_back(), C, move_to(2,2), C;
RB<<= 2,3,0,0,
4,5,0,0,
0,0,2,3,
0,0,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3, 4, 5;
B<<=fill_policy::sparse_push_back(), move(1,1), C;
RB<<= 0,0,0,0,
0,2,3,0,
0,4,5,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_push_back(), move_to(0,1), 2, 3, next_row(), 1, 2, next_row(), 4, 5;
RB<<= 0,2,3,0,
1,2,0,0,
4,5,0,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
// The next will not work with sparse push_back because elements that are prior to the ones already in are attempted to be added
/*
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, 6, next_column(), 4, 5;
RB<<= 0,2,4,0,
0,3,5,0,
0,6,0,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
*/
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, next_row(), traverse_policy::by_row(), 4, 5;
RB<<= 0,2,0,0,
0,3,0,0,
0,0,0,0,
4,5,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8;
RB<<= 0,2,0,0,
0,3,0,0,
4,5,6,7,
8,0,0,0;
pass &= compare_to(B, RB);
}
// The next will not work with sparse push_back because elements that are prior to the ones already in are attempted to be added
/*
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8,9, begin1(), 1, 2;
RB<<= 0,2,1,2,
0,3,0,0,
4,5,6,7,
8,9,0,0;
pass &= compare_to(B, RB);
}
*/
return pass;
}
template <class V>
bool test_matrix_sparse_insert() {
bool pass = true;
V A(3,3), RA(3,3);
A <<= fill_policy::sparse_insert(), 1, 2, 3, 4, 5, 6, 7, 8, 9;
RA(0,0)= 1; RA(0,1)=2; RA(0,2)=3;
RA(1,0)= 4; RA(1,1)=5; RA(1,2)=6;
RA(2,0)= 7; RA(2,1)=8; RA(2,2)=9;
pass &= compare_to(A, RA);
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(3);
b<<= 4,5,6;
B<<=fill_policy::sparse_insert(), 1, 2, 3, b, 7, project(b, range(1,3));
RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6; // If the first worked we can now probably use it.
pass &= compare_to(B, RB);
}
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(3);
b<<= 4,5,6;
B<<=fill_policy::sparse_insert(), move(1,0), b, fill_policy::sparse_insert(), move_to(0,0), 1, 2, 3, move(1,0), 7, project(b, range(1,3));
RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6;
pass &= compare_to(B, RB);
}
{
V B(3,3), RB(3,3);
vector<typename V::value_type> b(9);
b<<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
B<<=b;
RB<<=1, 2, 3, 4, 5, 6, 7, 8, 9;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3,
4, 5;
B<<=fill_policy::sparse_insert(), C, C, C, C;
RB <<= 2,3,2,3,
4,5,4,5,
2,3,2,3,
4,5,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3, 4, 5;
B<<=fill_policy::sparse_insert(), C, move_to(2,2), C;
RB<<= 2,3,0,0,
4,5,0,0,
0,0,2,3,
0,0,4,5;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
V C(2,2);
C <<= 2, 3, 4, 5;
B<<=fill_policy::sparse_insert(), move(1,1), C;
RB<<= 0,0,0,0,
0,2,3,0,
0,4,5,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_insert(), move_to(0,1), 2, 3, next_row(), 1, 2, next_row(), 4, 5;
RB<<= 0,2,3,0,
1,2,0,0,
4,5,0,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, 6, next_column(), 4, 5;
RB<<= 0,2,4,0,
0,3,5,0,
0,6,0,0,
0,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, next_row(), traverse_policy::by_row(), 4, 5;
RB<<= 0,2,0,0,
0,3,0,0,
0,0,0,0,
4,5,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8;
RB<<= 0,2,0,0,
0,3,0,0,
4,5,6,7,
8,0,0,0;
pass &= compare_to(B, RB);
}
{
V B(4,4), RB(4,4);
B = zero_matrix<typename V::value_type>(4,4);
B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8,9, begin1(), 1, 2;
RB<<= 0,2,1,2,
0,3,0,0,
4,5,6,7,
8,9,0,0;
pass &= compare_to(B, RB);
}
return pass;
}
BOOST_UBLAS_TEST_DEF (test_vector) {
BOOST_UBLAS_DEBUG_TRACE( "Starting operator \"<<= \" vector assignment tests" );
BOOST_UBLAS_TEST_CHECK(test_vector<vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector<vector<char> >());
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<double,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<float,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<long,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<unsigned long,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<int,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<unsigned int,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<std::size_t,7> >()));
BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<char,7> >()));
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<unsigned int> >())
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<std::size_t> >())
BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<char> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<char> >());
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<long> >())
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<unsigned long> >())
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<char> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<char> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<char> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<char> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<double> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<float> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<char> >());
}
BOOST_UBLAS_TEST_DEF (test_matrix) {
BOOST_UBLAS_DEBUG_TRACE( "Starting operator \"<<= \" matrix assignment tests" );
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<char> >());
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<double,7, 7> >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<float,7, 7> >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<long,7, 7> >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<unsigned long,7, 7> >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<int,7,7 > >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<unsigned int,7, 7> >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<char,7, 7> >()));
BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<std::size_t,7, 7> >()));
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<unsigned int> >())
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<std::size_t> >())
BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<char> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<char> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<long> >())
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<unsigned long> >())
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<char> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<char> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<char> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<char> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<double> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<float> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<unsigned long> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<unsigned int> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<std::size_t> >());
BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<char> >());
}
int main () {
BOOST_UBLAS_TEST_BEGIN();
BOOST_UBLAS_TEST_DO( test_vector );
BOOST_UBLAS_TEST_DO( test_matrix );
BOOST_UBLAS_TEST_END();
return EXIT_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink