From 79ef14291defa2313a950e64243dbb0dd7f59894 Mon Sep 17 00:00:00 2001 From: David Bellot Date: Sat, 19 Nov 2011 23:26:59 +0000 Subject: [PATCH] added new tests svn path=/trunk/libs/numeric/ublas/; revision=75560 --- test/Jamfile.v2 | 10 ++- test/README | 2 +- test/test_inplace_solve.cpp | 115 +++++++++++++++++++++++++++++ test/test_triangular.cpp | 139 ++++++++++++++++++++++++++++++++++++ 4 files changed, 262 insertions(+), 4 deletions(-) create mode 100644 test/test_inplace_solve.cpp create mode 100644 test/test_triangular.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 388561b1..27461270 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -1,4 +1,4 @@ -# Copyright (c) 2004 Michael Stevens +# Copyright (c) 2004-2011 Michael Stevens, David Bellot # Use, modification and distribution are subject to 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) @@ -132,6 +132,10 @@ test-suite numeric/uBLAS ] [ run test_complex_norms.cpp ] - [ run test_assignment.cpp - ] + [ run test_assignment.cpp + ] + [ run test_triangular.cpp + ] + [ run test_inplace_solve.cpp + ] ; diff --git a/test/README b/test/README index 2e3e7177..76112314 100644 --- a/test/README +++ b/test/README @@ -1,4 +1,4 @@ -Copyright (c) 2000-2004 Joerg Walter, Mathias Koch +Copyright (c) 2000-2011 Joerg Walter, Mathias Koch, David Bellot Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at diff --git a/test/test_inplace_solve.cpp b/test/test_inplace_solve.cpp new file mode 100644 index 00000000..83eff3d9 --- /dev/null +++ b/test/test_inplace_solve.cpp @@ -0,0 +1,115 @@ +#include + +#include +#include +#include +#include +#include + + +#include +#include +#include + +#include "utils.hpp" + +namespace ublas = boost::numeric::ublas; + +static const double TOL(1.0e-5); ///< Used for comparing two real numbers. +static const int n(10); ///< defines the test matrix size + +template +double diff(const mat& A, const vec& x, const vec& b) { + return ublas::norm_2(prod(A, x) - b); +} + +// efficiently fill matrix depending on majority +template +void fill_matrix(mat& A, ublas::column_major_tag) { + for (int i=0; i=0) { + A(i-1, i) = -1; + } + A(i, i) = 1; + if (i+1 +void fill_matrix(mat& A, ublas::row_major_tag) { + for (int i=0; i=0) { + A(i, i-1) = -1; + } + A(i, i) = 1; + if (i+1 +BOOST_UBLAS_TEST_DEF ( test_inplace_solve ) +{ + mat A(n, n); + A.clear(); + fill_matrix(A, typename mat::orientation_category()); + + ublas::vector b(n, 1.0); + + // The test matrix is not triangular, but is interpreted that way by + // inplace_solve using the lower_tag/upper_tags. For checking, the + // triangular_adaptor makes A triangular for comparison. + { + ublas::vector x(b); + ublas::inplace_solve(A, x, ublas::lower_tag()); + BOOST_UBLAS_TEST_CHECK(diff(ublas::triangular_adaptor(A), x, b) < TOL); + } + { + ublas::vector x(b); + ublas::inplace_solve(A, x, ublas::upper_tag()); + BOOST_UBLAS_TEST_CHECK(diff (ublas::triangular_adaptor(A), x, b) < TOL); + } + { + ublas::vector x(b); + ublas::inplace_solve(x, A, ublas::lower_tag()); + BOOST_UBLAS_TEST_CHECK(diff (trans(ublas::triangular_adaptor(A)), x, b) < TOL); + } + { + ublas::vector x(b); + ublas::inplace_solve(x, A, ublas::upper_tag()); + BOOST_UBLAS_TEST_CHECK(diff (trans(ublas::triangular_adaptor(A)), x , b) < TOL); + } +} + +int main() { + const int n=10; + + // typedefs are needed as macros do not work with "," in template arguments + typedef ublas::compressed_matrix commat_doub_rowmaj; + typedef ublas::compressed_matrix commat_doub_colmaj; + typedef ublas::matrix mat_doub_rowmaj; + typedef ublas::matrix mat_doub_colmaj; + typedef ublas::mapped_matrix mapmat_doub_rowmaj; + typedef ublas::mapped_matrix mapmat_doub_colmaj; + typedef ublas::coordinate_matrix cormat_doub_rowmaj; + typedef ublas::coordinate_matrix cormat_doub_colmaj; + typedef ublas::mapped_vector_of_mapped_vector mvmv_doub_rowmaj; + typedef ublas::mapped_vector_of_mapped_vector mvmv_doub_colmaj; + + BOOST_UBLAS_TEST_BEGIN(); + + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + BOOST_UBLAS_TEST_DO( test_inplace_solve ); + + BOOST_UBLAS_TEST_END(); +} diff --git a/test/test_triangular.cpp b/test/test_triangular.cpp new file mode 100644 index 00000000..56b1d344 --- /dev/null +++ b/test/test_triangular.cpp @@ -0,0 +1,139 @@ +#include + +#include +#include +#include +#include +#include + + +#include +#include +#include + + +namespace ublas = boost::numeric::ublas; + +template +double diff(const mat& A, const vec& x, const vec& b) { + vec temp(prod(A, x) - b); + double result = 0; + for (typename vec::size_type i=0; i +double diff(const vec& x, const mat& A, const vec& b) { + return diff(trans(A), x, b); +} + +namespace ublas = boost::numeric::ublas; + + +int main() { + const int n=10000; +#if 1 + ublas::compressed_matrix mat_row_upp(n, n); + ublas::compressed_matrix mat_col_upp(n, n); + ublas::compressed_matrix mat_row_low(n, n); + ublas::compressed_matrix mat_col_low(n, n); +#else + ublas::matrix mat_row_upp(n, n, 0); + ublas::matrix mat_col_upp(n, n, 0); + ublas::matrix mat_row_low(n, n, 0); + ublas::matrix mat_col_low(n, n, 0); +#endif + ublas::vector b(n, 1); + + std::cerr << "Constructing..." << std::endl; + for (int i=0; i=0) { + mat_row_low(i, i-1) = side; + } + mat_row_low(i, i) = main; + + mat_col_low(i, i) = main; + if (i+1=0) { + mat_col_upp(i-1, i) = side; + } + mat_col_upp(i, i) = main; + } + + std::cerr << "Starting..." << std::endl; + { + clock_t start = clock(); + ublas::vector x(b); + ublas::inplace_solve(mat_col_low, x, ublas::lower_tag()); + std::cerr << "Col_low x: " << clock()-start << std::endl; + std::cerr << "delta: " << diff(mat_col_low, x, b) << "\n"; + } + { + clock_t start = clock(); + ublas::vector x(b); + ublas::inplace_solve(mat_row_low, x, ublas::lower_tag()); + std::cerr << "Row_low x: " << clock()-start << std::endl; + std::cerr << "delta: " << diff(mat_row_low, x, b) << "\n"; + } + + { + clock_t start = clock(); + ublas::vector x(b); + ublas::inplace_solve(mat_col_upp, x, ublas::upper_tag()); + std::cerr << "col_upp x: " << clock()-start << std::endl; + std::cerr << "delta: " << diff(mat_col_upp, x, b) << "\n"; + } + { + clock_t start = clock(); + ublas::vector x(b); + ublas::inplace_solve(mat_row_upp, x, ublas::upper_tag()); + std::cerr << "row_upp x: " << clock()-start << std::endl; + std::cerr << "delta: " << diff(mat_row_upp, x, b) << "\n"; + } + +// { +// clock_t start = clock(); +// ublas::vector x(b); +// ublas::inplace_solve(x, mat_col_low, ublas::lower_tag()); +// std::cerr << "x col_low: " << clock()-start << std::endl; +// std::cerr << "delta: " << diff(x, mat_col_low, b) << "\n"; +// } + { + clock_t start = clock(); + ublas::vector x(b); + ublas::inplace_solve(x, mat_row_low, ublas::lower_tag()); + std::cerr << "x row_low: " << clock()-start << std::endl; + std::cerr << "delta: " << diff(x, mat_row_low, b) << "\n"; + } + +// { +// clock_t start = clock(); +// ublas::vector x(b); +// ublas::inplace_solve(x, mat_col_upp, ublas::upper_tag()); +// std::cerr << "x col_upp: " << clock()-start << std::endl; +// std::cerr << "delta: " << diff(x, mat_col_upp, b) << "\n"; +// } + { + clock_t start = clock(); + ublas::vector x(b); + ublas::inplace_solve(x, mat_row_upp, ublas::upper_tag()); + std::cerr << "x row_upp: " << clock()-start << std::endl; + std::cerr << "delta: " << diff(x, mat_row_upp, b) << "\n"; + } + + +}