diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/gbsv.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gbsv.hpp --- ./boost/numeric/bindings/lapack/gbsv.hpp 2008-04-05 20:39:39.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gbsv.hpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,136 +0,0 @@ -// -// Copyright Vardan Akopian 2007 -// -// 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) -// - -#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP -#define BOOST_NUMERIC_BINDINGS_LAPACK_GBSV_HPP - -#include -#include -#include -#include -#include - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK -# include -# include -#endif - - -namespace boost { namespace numeric { namespace bindings { - - namespace lapack { - - - namespace detail { - inline - void gbtrf (int const n, int const m, int const kl, int const ku, - double* ab, int const ldab, int* ipiv, int* info) - { - LAPACK_DGBTRF (&n, &m, &kl, &ku, ab, &ldab, ipiv, info); - } - } - - template - inline - int gbtrf (MatrA& a, IVec& ipiv) { - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK - BOOST_STATIC_ASSERT((boost::is_same< - typename traits::matrix_traits::matrix_structure, - traits::banded_t - >::value)); - BOOST_STATIC_ASSERT((boost::is_same< - typename traits::matrix_traits::ordering_type, - traits::row_major_t - >::value)); -#endif - - int const n = traits::matrix_size1 (a); - int const m = traits::matrix_size2 (a); - assert (traits::vector_size (ipiv) == (m < n ? m : n)); - - // if the matrix has kl lower and ku upper diagonals, then we should have - // allocated kl lower and kl+ku upper diagonals - int const kl = traits::matrix_lower_bandwidth (a); - int const ku = traits::matrix_upper_bandwidth (a) - kl; - int const ld = traits::leading_dimension (a); - - assert(ku > 0); - - int info; - detail::gbtrf (n, m, kl, ku, - traits::matrix_storage (a), - ld, - traits::vector_storage (ipiv), - &info); - return info; - } - - - namespace detail { - inline - void gbtrs (char const trans, int const n, int const kl, int const ku, int const m, - double const* ab, int const ldab, int const* ipiv, - double* b, int const ldb, int* info) - { - LAPACK_DGBTRS (&trans, &n, &kl, &ku, &m, ab, &ldab, ipiv, b, &ldb, info); - } - } - - - template - inline - int gbtrs (char const trans, MatrA const& a, IVec const& ipiv, MatrB& b) - { - assert (trans == 'N' || trans == 'T' || trans == 'C'); - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK - BOOST_STATIC_ASSERT((boost::is_same< - typename traits::matrix_traits::matrix_structure, - traits::banded_t - >::value)); -#endif - - int const n = traits::matrix_size1 (a); - assert (n == traits::matrix_size2 (a)); - assert (n == traits::matrix_size1 (b)); - assert (n == traits::vector_size (ipiv)); - - // if the matrix has kl lower and ku upper diagonals, then we should have - // allocated kl lower and kl+ku upper diagonals - int const kl = traits::matrix_lower_bandwidth (a); - int const ku = traits::matrix_upper_bandwidth (a) - kl; - int const ld = traits::leading_dimension (a); - - assert(ku > 0); - - int info; - detail::gbtrs (trans, n, kl, ku, traits::matrix_size2 (b), -#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING - traits::matrix_storage (a), -#else - traits::matrix_storage_const (a), -#endif - ld, -#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING - traits::vector_storage (ipiv), -#else - traits::vector_storage_const (ipiv), -#endif - traits::matrix_storage (b), - traits::leading_dimension (b), - &info); - return info; - } - - - } - -}}} - -#endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/geev.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/geev.hpp --- ./boost/numeric/bindings/lapack/geev.hpp 2008-06-10 13:06:24.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/geev.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -99,11 +99,11 @@ { int info; LAPACK_CGEEV(jobvl, jobvr, n, - reinterpret_cast(a), lda, - reinterpret_cast(w), - reinterpret_cast(vl), ldvl, - reinterpret_cast(vr), ldvr, - reinterpret_cast(work), lwork, + traits::complex_ptr(a), lda, + traits::complex_ptr(w), + traits::complex_ptr(vl), ldvl, + traits::complex_ptr(vr), ldvr, + traits::complex_ptr(work), lwork, rwork, &info); return info; } @@ -116,11 +116,11 @@ { int info; LAPACK_ZGEEV(jobvl, jobvr, n, - reinterpret_cast(a), lda, - reinterpret_cast(w), - reinterpret_cast(vl), ldvl, - reinterpret_cast(vr), ldvr, - reinterpret_cast(work), lwork, + traits::complex_ptr(a), lda, + traits::complex_ptr(w), + traits::complex_ptr(vl), ldvl, + traits::complex_ptr(vr), ldvr, + traits::complex_ptr(work), lwork, rwork, &info); return info; } diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/gelsd.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gelsd.hpp --- ./boost/numeric/bindings/lapack/gelsd.hpp 2008-04-10 09:27:04.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gelsd.hpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,420 +0,0 @@ -// -// Copyright Jesse Manning 2007 -// -// 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) -// - -#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSD_HPP -#define BOOST_NUMERIC_BINDINGS_LAPACK_GELSD_HPP - -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -// included to implicitly convert a vector to an nx1 matrix -// so that it is compatible with lapack binding -#include - - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK -# include -# include -#endif - -namespace boost { namespace numeric { namespace bindings { - - namespace lapack { - - namespace detail { - - inline void gelsd(const int m, const int n, const int nrhs, - float *a, const int lda, float *b, const int ldb, - float *s, const float rcond, int *rank, float *work, - const int lwork, int *iwork, int *info) - { - LAPACK_SGELSD(&m, &n, &nrhs, a, &lda, b, &ldb, s, - &rcond, rank, work, &lwork, iwork, info); - } - - inline void gelsd(const int m, const int n, const int nrhs, - double *a, const int lda, double *b, const int ldb, - double *s, const double rcond, int *rank, double *work, - const int lwork, int *iwork, int *info) - { - LAPACK_DGELSD(&m, &n, &nrhs, a, &lda, b, &ldb, s, - &rcond, rank, work, &lwork, iwork, info); - } - - inline void gelsd(const int m, const int n, const int nrhs, - traits::complex_f *a, const int lda, traits::complex_f *b, - const int ldb, float *s, const float rcond, int *rank, - traits::complex_f *work, const int lwork, float *rwork, - int *iwork, int *info) - { - LAPACK_CGELSD(&m, &n, &nrhs, traits::complex_ptr(a), - &lda, traits::complex_ptr(b), &ldb, s, - &rcond, rank, traits::complex_ptr(work), - &lwork, rwork, iwork, info); - } - - inline void gelsd(const int m, const int n, const int nrhs, - traits::complex_d *a, const int lda, traits::complex_d *b, - const int ldb, double *s, const double rcond, int *rank, - traits::complex_d *work, const int lwork, double *rwork, - int *iwork, int *info) - { - LAPACK_ZGELSD(&m, &n, &nrhs, traits::complex_ptr(a), - &lda, traits::complex_ptr(b), &ldb, s, - &rcond, rank, traits::complex_ptr(work), - &lwork, rwork, iwork, info); - } - - // gelsd for real type - template - inline int gelsd(MatrA& A, MatrB& B, VecS& s, Work& work) - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - const int maxmn = std::max(m, n); - const int minmn = std::min(m, n); - - // sanity checks - assert(m >= 0 && n >= 0); - assert(nrhs >= 0); - assert(traits::leading_dimension(A) >= std::max(1, m)); - assert(traits::leading_dimension(B) >= std::max(1, maxmn)); - assert(traits::vector_size(work) >= 1); - assert(traits::vector_size(s) >= std::max(1, minmn)); - - int info; - const real_t rcond = -1; // use machine precision - int rank; - - // query for maximum size of subproblems - const int smlsiz = ilaenv(9, "GELSD", ""); - const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); - - traits::detail::array iwork(3*minmn*nlvl + 11*minmn); - - detail::gelsd(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - traits::vector_storage(work), - traits::vector_size(work), - traits::vector_storage(iwork), - &info); - - return info; - } - - // gelsd for complex type - template - inline int gelsd(MatrA& A, MatrB& B, VecS& s, Work& work, RWork& rwork) - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - const int maxmn = std::max(m, n); - const int minmn = std::min(m, n); - - // sanity checks - assert(m >= 0 && n >= 0); - assert(nrhs >= 0); - assert(traits::leading_dimension(A) >= std::max(1, m)); - assert(traits::leading_dimension(B) >= std::max(1, maxmn)); - assert(traits::vector_size(work) >= 1); - assert(traits::vector_size(s) >= std::max(1, minmn)); - - int info; - const real_t rcond = -1; // use machine precision - int rank; - - // query for maximum size of subproblems - const int smlsiz = ilaenv(9, "GELSD", ""); - const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); - - traits::detail::array iwork(3*minmn*nlvl + 11*minmn); - - detail::gelsd(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - traits::vector_storage(work), - traits::vector_size(work), - traits::vector_storage(rwork), - traits::vector_storage(iwork), - &info); - - return info; - } - - template - struct Gelsd { }; - - // specialization for gelsd real flavors (sgelsd, dgelsd) - template <> - struct Gelsd<1> - { - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const - { - typedef typename MatrA::value_type val_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs - - // query for maximum size of subproblems - const int smlsiz = ilaenv(9, "GELSD", ""); - const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); - - const int lwork = 12*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + - minmn*nrhs + (smlsiz+1)*(smlsiz+1); - - traits::detail::array work(lwork); - - return gelsd(A, B, s, work); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs - - val_t temp_work; - int temp_iwork; - - const real_t rcond = -1; - int rank; - int info; - - // query for optimal workspace size - detail::gelsd(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - &temp_work, //traits::vector_storage(work), - -1, //traits::vector_size(work), - &temp_iwork, - &info); - - assert(info == 0); - - const int lwork = traits::detail::to_int(temp_work); - - traits::detail::array work(lwork); - - return gelsd(A, B, s, work); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace1& workspace) const - { - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs - - return gelsd(A, B, s, workspace.w_); - } - }; - - // specialization for gelsd (cgelsd, zgelsd) - template <> - struct Gelsd<2> - { - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs - - // query for maximum size of subproblems - const int smlsiz = ilaenv(9, "GELSD", ""); - const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); - - traits::detail::array work(2*minmn + minmn*nrhs); - - const int rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + - 3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1); - - traits::detail::array rwork(std::max(1, rwork_size)); - - return gelsd(A, B, s, work, rwork); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs - - val_t temp_work; - real_t temp_rwork; - int temp_iwork; - - const real_t rcond = -1; - int rank; - int info; - - // query for optimal workspace size - detail::gelsd(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - &temp_work, //traits::vector_storage(work), - -1, //traits::vector_size(work), - &temp_rwork, - &temp_iwork, - &info); - - assert(info == 0); - - const int lwork = traits::detail::to_int(temp_work); - - traits::detail::array work(lwork); - - // query for maximum size of subproblems - const int smlsiz = ilaenv(9, "GELSD", ""); - const int nlvl = static_cast(((std::log(static_cast(minmn))/std::log(2.f))/ (smlsiz+1)) + 1); - - const int rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + - 3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1); - - traits::detail::array rwork(std::max(1, rwork_size)); - - return gelsd(A, B, s, work, rwork); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace2& workspace) const - { - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs - - return gelsd(A, B, s, workspace.w_, workspace.wr_); - } - }; - - } // detail - - // gelsd - // Parameters: - // A: matrix of coefficients - // B: matrix of solutions (stored column-wise) - // s: vector to store singular values on output, length >= max(1, min(m,n)) - // workspace: either optimal, minimal, or user supplied - // - template - inline int gelsd(MatrA& A, MatrB& B, VecS& s, Work& workspace) - { - typedef typename MatrA::value_type val_t; - - return detail::Gelsd::value>() (A, B, s, workspace); - } - - // gelsd, no singular values are returned - // Parameters: - // A: matrix of coefficients - // B: matrix of solutions (stored column-wise) - // workspace: either optimal, minimal, or user supplied - // - template - inline int gelsd(MatrA& A, MatrB& B, Work& workspace) - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - - const int s_size = std::max(1, std::min(m,n)); - traits::detail::array s(s_size); - - return detail::Gelsd::value>() (A, B, s, workspace); - } - - } // lapack - -}}} - -#endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/gels.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gels.hpp --- ./boost/numeric/bindings/lapack/gels.hpp 2008-04-10 09:26:34.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gels.hpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,213 +0,0 @@ -// -// Copyright Jesse Manning 2007 -// -// 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) -// - -#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELS_HPP -#define BOOST_NUMERIC_BINDINGS_LAPACK_GELS_HPP - -#include - -#include -#include -#include -#include -#include -#include -#include - -// included to implicitly convert a vector to an nx1 matrix -// so that it is compatible with lapack binding -#include - - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK -# include -# include -#endif - -namespace boost { namespace numeric { namespace bindings { - - namespace lapack { - - //////////////////////////////////////////////////////////////////////// - // - // Linear Least Squares of an underdetermined or overdetermined matrix - // - /////////////////////////////////////////////////////////////////////// - - /* gels - uses the LQ or QR factorization to solve an overdetermined - * or underdetermined linear system. A full rank matrix is - * assumed. - * - * The linear least squares system is defined by A*x=b. A is the m-by-n - * coefficients matrix and b is the m-by-nrhs matrix. Several - * right hand side vectors b and solution vectors x can be handled in - * a single call; they are stored as the columns of the m-by-nrhs right - * hand side matrix B and the n-by-nrh solution matrix x. - * - * If trans = 'N' and m >= n: find least squares solution of overdetermined system - * minimizes || b - A x ||2 - * - * if trans = 'N' and m < n: find minimum norm solution of underdetermined system - * A*X = B - * - * if trans = 'T' or 'C' and m >= n: find minimum norm soltion of underdetermined system - * A^H*X = B - * - * if trans = 'T' or 'C' and m < n: find least squares solution of overdetermined system - * minimize || b - A^H x ||2 - * - * Workspace is organized following the arguments in the calling sequence. - * optimal_workspace() : for optimizing use of blas 3 kernels - * minimal_workspace() : minimum size of work arrays, but does not allow for optimization - * of blas 3 kernels - * workspace( work ) : where work size must be at least min(m, n) + max(1, m, n, nrhs) - * - * - * Each solution vector x (length n) is returned column-wise in the rhs matrix B. - */ - - namespace detail { - - inline void gels(char const trans, const int m, const int n, - const int nrhs, float *a, const int lda, - float *b, const int ldb, float *work, - const int lwork, int *info) - { - LAPACK_SGELS(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info); - } - - inline void gels(char const trans, const int m, const int n, - const int nrhs, double *a, const int lda, - double *b, const int ldb, double *work, - const int lwork, int *info) - { - LAPACK_DGELS(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info); - } - - inline void gels(char const trans, const int m, const int n, - const int nrhs, traits::complex_f *a, const int lda, - traits::complex_f *b, const int ldb, traits::complex_f *work, - const int lwork, int *info) - { - LAPACK_CGELS(&trans, &m, &n, &nrhs, - traits::complex_ptr(a), &lda, - traits::complex_ptr(b), &ldb, - traits::complex_ptr(work), &lwork, info); - } - - inline void gels(char const trans, const int m, const int n, - const int nrhs, traits::complex_d *a, const int lda, - traits::complex_d *b, const int ldb, traits::complex_d *work, - const int lwork, int *info) - { - LAPACK_ZGELS(&trans, &m, &n, &nrhs, - traits::complex_ptr(a), &lda, - traits::complex_ptr(b), &ldb, - traits::complex_ptr(work), &lwork, info); - } - - // generic function that calls more detailed lapack function - template - int gels(const char trans, MatrA& A, VecB& b, Work& work) - { - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int mrhs = traits::matrix_size1(b); - const int nrhs = traits::matrix_size2(b); - - // sanity checks - assert(trans == 'N' || trans == 'T' || trans == 'C'); - assert(m >= 0 && n >= 0); - assert(mrhs >= 0 && nrhs >= 0); - assert(traits::leading_dimension(A) >= 1 && traits::leading_dimension(b) >= 1); - assert(mrhs == std::max(m, n)); - - int info; - detail::gels(trans, - traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(b), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(b), - traits::leading_dimension(b), - traits::vector_storage(work), - traits::vector_size(work), - &info); - - return info; - } - - // query for recommended workspace - template - inline - int gels_optimal_work(const char trans, MatrA& A, VecB& b) - { - MatrA::value_type work; - int info; - detail::gels(trans, - traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(b), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(b), - traits::leading_dimension(b), - &work, //traits::vector_storage(work), - -1, // traits::vector_size(work), - &info); - - assert(info == 0); - - int lwork = traits::detail::to_int(work); - - return lwork; - } - } // namespace detail - - - template - inline - int gels(const char trans, MatrA& A, VecB& b, optimal_workspace) - { - // query optimal workspace size - int work_size = detail::gels_optimal_work(trans, A, b); - traits::detail::array work(work_size); - - return detail::gels(trans, A, b, work); - } - - template - inline - int gels(const char trans, MatrA& A, VecB& b, minimal_workspace) - { - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int r = traits::matrix_size2(b); - - const int minmn = std::min(m, n); //m < n ? m : n; - const int maxmn = std::max(m, n); // m > n ? m : n; - const int maxdim = std::max(maxmn, r); // maxmn > r ? maxmn : r; - - traits::detail::array work(minmn + std::max(1, maxdim)); - - return detail::gels(trans, A, b, work); - } - - template - inline - int gels(const char trans, MatrA& A, VecB& b, detail::workspace1 workspace) - { - return detail::gels(trans, A, b, workspace.w_); - } - - } // namespace lapack - -}}} - -#endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/gelss.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gelss.hpp --- ./boost/numeric/bindings/lapack/gelss.hpp 2008-04-10 09:27:12.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gelss.hpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,358 +0,0 @@ -// -// Copyright Jesse Manning 2007 -// -// 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) -// - -#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GELSS_HPP -#define BOOST_NUMERIC_BINDINGS_LAPACK_GELSS_HPP - -#include - -#include -#include -#include -#include -#include -#include -#include - -// included to implicitly convert a vector to an nx1 matrix -// so that it is compatible with lapack binding -#include - - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK -# include -# include -#endif - -namespace boost { namespace numeric { namespace bindings { - - namespace lapack { - - namespace detail { - - inline void gelss(const int m, const int n, const int nrhs, - float *a, const int lda, float *b, const int ldb, - float *s, const float rcond, int *rank, float *work, - const int lwork, int *info) - { - LAPACK_SGELSS(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info); - } - - inline void gelss(const int m, const int n, const int nrhs, - double *a, const int lda, double *b, const int ldb, - double *s, const double rcond, int *rank, double *work, - const int lwork, int *info) - { - LAPACK_DGELSS(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info); - } - - inline void gelss(const int m, const int n, const int nrhs, - traits::complex_f *a, const int lda, traits::complex_f *b, - const int ldb, float *s, const float rcond, int *rank, - traits::complex_f *work, const int lwork, float *rwork, int *info) - { - LAPACK_CGELSS(&m, &n, &nrhs, traits::complex_ptr(a), - &lda, traits::complex_ptr(b), &ldb, s, - &rcond, rank, traits::complex_ptr(work), - &lwork, rwork, info); - } - - inline void gelss(const int m, const int n, const int nrhs, - traits::complex_d *a, const int lda, traits::complex_d *b, - const int ldb, double *s, const double rcond, int *rank, - traits::complex_d *work, const int lwork, double *rwork, int *info) - { - LAPACK_ZGELSS(&m, &n, &nrhs, traits::complex_ptr(a), - &lda, traits::complex_ptr(b), &ldb, s, - &rcond, rank, traits::complex_ptr(work), - &lwork, rwork, info); - } - - // gelss for real type - template - inline int gelss(MatrA& A, MatrB& B, VecS& s, Work& work) - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - const int maxmn = std::max(m, n); - const int minmn = std::min(m, n); - - // sanity checks - assert(m >= 0 && n >= 0); - assert(nrhs >= 0); - assert(traits::leading_dimension(A) >= std::max(1, m)); - assert(traits::leading_dimension(B) >= std::max(1, maxmn)); - assert(traits::vector_size(work) >= 1); - assert(traits::vector_size(s) >= std::max(1, minmn)); - - int info; - const real_t rcond = -1; // use machine precision - int rank; - - detail::gelss(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - traits::vector_storage(work), - traits::vector_size(work), - &info); - - return info; - } - - // gelss for complex type - template - inline int gelss(MatrA& A, MatrB& B, VecS& s, Work& work, RWork& rwork) - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int nrhs = traits::matrix_size2(B); - const int maxmn = std::max(m, n); - const int minmn = std::min(m, n); - - // sanity checks - assert(m >= 0 && n >= 0); - assert(nrhs >= 0); - assert(traits::leading_dimension(A) >= std::max(1, m)); - assert(traits::leading_dimension(B) >= std::max(1, maxmn)); - assert(traits::vector_size(work) >= 1); - assert(traits::vector_size(s) >= std::max(1, minmn)); - - int info; - const real_t rcond = -1; // use machine precision - int rank; - - detail::gelss(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - traits::vector_storage(work), - traits::vector_size(work), - traits::vector_storage(rwork), - &info); - - return info; - } - - // default minimal workspace functor - template - struct Gelss { }; - - // specialization for gelss (sgelss, dgelss) - template <> - struct Gelss<1> - { - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const - { - typedef typename MatrA::value_type val_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int rhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs - - traits::detail::array work(3*minmn + std::max(2*minmn, maxmnr)); - - return gelss(A, B, s, work); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int rhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs - - val_t temp_work; - - const real_t rcond = -1; - int rank; - int info; - - // query for optimal workspace size - detail::gelss(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - &temp_work, //traits::vector_storage(work), - -1, //traits::vector_size(work), - &info); - - assert(info == 0); - - const int lwork = traits::detail::to_int(temp_work); - - traits::detail::array work(lwork); - - return gelss(A, B, s, work); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace1& workspace) const - { - return gelss(A, B, s, workspace.w_); - } - }; - - // specialization for gelss (cgelss, zgelss) - template <> - struct Gelss<2> - { - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, minimal_workspace) const - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int rhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs - - traits::detail::array work(2*minmn + maxmnr); - traits::detail::array rwork(std::max(1, (5*minmn))); - - return gelss(A, B, s, work, rwork); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, optimal_workspace) const - { - typedef typename MatrA::value_type val_t; - typedef traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - const int rhs = traits::matrix_size2(B); - - const int minmn = std::min(m, n); // minmn = m < n ? m : n - const int maxmn = std::max(m, n); // maxmn = m > n ? m : n - const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs - - val_t temp_work; - real_t temp_rwork; - - const real_t rcond = -1; - int rank; - int info; - - // query for optimal workspace size - detail::gelss(traits::matrix_size1(A), - traits::matrix_size2(A), - traits::matrix_size2(B), - traits::matrix_storage(A), - traits::leading_dimension(A), - traits::matrix_storage(B), - traits::leading_dimension(B), - traits::vector_storage(s), - rcond, - &rank, - &temp_work, //traits::vector_storage(work), - -1, //traits::vector_size(work), - &temp_rwork, - &info); - - assert(info == 0); - - const int lwork = traits::detail::to_int(temp_work); - - traits::detail::array work(lwork); - traits::detail::array rwork(std::max(1, (5*minmn))); - - return gelss(A, B, s, work, rwork); - } - - template - inline int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace2& workspace) const - { - return gelss(A, B, s, workspace.w_, workspace.wr); - } - }; - - } // detail - - // gelss - // Parameters: - // A: matrix of coefficients - // B: matrix of solutions (stored column-wise) - // s: vector to store singular values on output, length >= max(1, min(m,n)) - // workspace: either optimal, minimal, or user supplied - // - template - inline int gelss(MatrA& A, MatrB& B, VecS& s, Work& workspace) - { - typedef typename MatrA::value_type val_t; - - return detail::Gelss::value>() (A, B, s, workspace); - } - - // gelss, no singular values are returned - // Parameters: - // A: matrix of coefficients - // B: matrix of solutions (stored column-wise) - // workspace: either optimal, minimal, or user supplied - // - template - inline int gelss(MatrA& A, MatrB& B, Work& workspace) - { - typedef typename MatrA::value_type val_t; - typedef typename traits::type_traits::real_type real_t; - - const int m = traits::matrix_size1(A); - const int n = traits::matrix_size2(A); - - const int s_size = std::max(1, std::min(m,n)); - traits::detail::array s(s_size); - - return detail::Gelss::value>() (A, B, s, workspace); - } - - } // namespace lapack - -}}} - -#endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/geqrf.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/geqrf.hpp --- ./boost/numeric/bindings/lapack/geqrf.hpp 2008-06-10 13:04:05.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/geqrf.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -25,6 +25,7 @@ # include # include #endif +#include namespace boost { namespace numeric { namespace bindings { @@ -108,7 +109,7 @@ int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); - assert (std::min(m,n) <= traits::vector_size (tau)); + assert (std::min(m,n) <= traits::vector_size (tau)); assert (n <= traits::vector_size (work)); int info; @@ -130,7 +131,7 @@ int geqrf (A& a, Tau& tau, optimal_workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); - traits::detail::array work(std::max(1, n*32)); + traits::detail::array work(std::max(1, n*32)); return geqrf( a, tau, work ); } @@ -142,7 +143,7 @@ int geqrf (A& a, Tau& tau, minimal_workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); - traits::detail::array work(std::max(1, n)); + traits::detail::array work(std::max(1, n)); return geqrf( a, tau, work ); } @@ -156,7 +157,7 @@ int geqrf (A& a, Tau& tau, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); - traits::detail::array work(std::max(1, n)); + traits::detail::array work(std::max(1, n)); return geqrf( a, tau, workspace.w_ ); } diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/gesvd.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gesvd.hpp --- ./boost/numeric/bindings/lapack/gesvd.hpp 2008-06-10 13:04:48.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/gesvd.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -49,7 +49,7 @@ * diagonal elements, U is an M-by-M orthogonal/unitary matrix, and V * is an N-by-N orthogonal/unitary matrix. The diagonal elements of S * are the singular values of A; they are real and non-negative, and - * are returned in descending order. The first min(m,n) columns of + * are returnede in descending order. The first min(m,n) columns of * U and V are the left and right singular vectors of A. (Note that * the routine returns V^T or V^H, not V. */ @@ -275,9 +275,7 @@ int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); -#ifndef NDEBUG /* this variable is only used in assertions below */ int const minmn = m < n ? m : n; -#endif assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); @@ -342,9 +340,7 @@ int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); -#ifndef NDEBUG /* this variable is only used in assertions below */ int const minmn = m < n ? m : n; -#endif assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); @@ -409,9 +405,7 @@ int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); -#ifndef NDEBUG /* this variable is only used in assertions below */ int const minmn = m < n ? m : n; -#endif assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); @@ -423,7 +417,7 @@ || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); - assert (n == traits::matrix_size2 (vt)); + assert ((jobvt == 'N' || traits::matrix_size2(vt) == n)) ; assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) @@ -496,9 +490,7 @@ int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); -#ifndef NDEBUG /* this variable is only used in assertions below */ int const minmn = m < n ? m : n; -#endif assert (minmn == traits::vector_size (s)); diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/heevd.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/heevd.hpp --- ./boost/numeric/bindings/lapack/heevd.hpp 2008-05-01 13:10:13.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/heevd.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -94,9 +94,9 @@ { LAPACK_CHEEVD ( &jobz, &uplo, &n, - reinterpret_cast(a), &lda, - reinterpret_cast(w), - reinterpret_cast(work), &lwork, + traits::complex_ptr(a), &lda, + w, + traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork, &info); } @@ -108,9 +108,9 @@ { LAPACK_ZHEEVD ( &jobz, &uplo, &n, - reinterpret_cast(a), &lda, - reinterpret_cast(w), - reinterpret_cast(work), &lwork, + traits::complex_ptr(a), &lda, + w, + traits::complex_ptr(work), &lwork, rwork, &lrwork, iwork, &liwork, &info); } } // namespace detail @@ -167,8 +167,8 @@ T* a, int const lda, R* w, std::pair, detail::workspace1 > work, int& info) { - assert (jobz=='N' ? 1+2*n : 1+6*n+2*n*n <= traits::vector_size (work.first.w_)); - assert (jobz=='N' ? 1 : 3+5*n <= traits::vector_size (work.second.w_)); + assert (traits::vector_size (work.first.w_) >= jobz=='N' ? 1+2*n : 1+6*n+2*n*n); + assert (traits::vector_size (work.second.w_) >= jobz=='N' ? 1 : 3+5*n); heevd( jobz, uplo, n, a, lda, w, traits::vector_storage (work.first.w_), traits::vector_size (work.first.w_), @@ -229,9 +229,9 @@ T* a, int const lda, R* w, std::pair, detail::workspace1 > work, int& info) { - assert (jobz=='N' ? 1+n : 2*n+n*n <= traits::vector_size (work.first.w_)); - assert (jobz=='N' ? n : 1+5*n+2*n*n <= traits::vector_size (work.first.wr_)); - assert (jobz=='N' ? 1 : 3+5*n <= traits::vector_size (work.second.w_)); + assert (traits::vector_size (work.first.w_) >= jobz=='N' ? 1+n : 2*n+n*n); + assert (traits::vector_size (work.first.wr_) >= jobz=='N' ? n : 1+5*n+2*n*n); + assert (traits::vector_size (work.second.w_) >= jobz=='N' ? 1 : 3+5*n); heevd( jobz, uplo, n, a, lda, w, traits::vector_storage (work.first.w_), traits::vector_size (work.first.w_), diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/heev.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/heev.hpp --- ./boost/numeric/bindings/lapack/heev.hpp 2008-06-10 12:56:51.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/heev.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -63,8 +63,8 @@ float* rwork, int& info) { LAPACK_CHEEV (&jobz, &uplo, &n, - reinterpret_cast(a), &lda, w, - reinterpret_cast(work), &lwork, + traits::complex_ptr(a), &lda, w, + traits::complex_ptr(work), &lwork, rwork, &info); } @@ -75,8 +75,8 @@ double* rwork, int& info) { LAPACK_ZHEEV (&jobz, &uplo, &n, - reinterpret_cast(a), &lda, w, - reinterpret_cast(work), &lwork, + traits::complex_ptr(a), &lda, w, + traits::complex_ptr(work), &lwork, rwork, &info); } diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/heevx.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/heevx.hpp --- ./boost/numeric/bindings/lapack/heevx.hpp 2008-05-01 05:30:59.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/heevx.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -109,10 +109,10 @@ { LAPACK_CHEEVX ( &jobz, &range, &uplo, &n, - reinterpret_cast(a), &lda, + traits::complex_ptr(a), &lda, &vl, &vu, &il, &iu, &abstol, &m, w, - reinterpret_cast(z), &ldz, - reinterpret_cast(work), &lwork, + traits::complex_ptr(z), &ldz, + traits::complex_ptr(work), &lwork, rwork, iwork, ifail, &info); } @@ -126,10 +126,10 @@ { LAPACK_ZHEEVX ( &jobz, &range, &uplo, &n, - reinterpret_cast(a), &lda, + traits::complex_ptr(a), &lda, &vl, &vu, &il, &iu, &abstol, &m, w, - reinterpret_cast(z), &ldz, - reinterpret_cast(work), &lwork, + traits::complex_ptr(z), &ldz, + traits::complex_ptr(work), &lwork, rwork, iwork, ifail, &info); } } // namespace detail @@ -192,8 +192,8 @@ R abstol, int& m, R* w, T* z, int const ldz, std::pair, detail::workspace1 > work, int* ifail, int& info) { - assert (8*n <= traits::vector_size (work.first.w_)); - assert (5*n <= traits::vector_size (work.second.w_)); + assert (traits::vector_size (work.first.w_) >= 8*n); + assert (traits::vector_size (work.second.w_) >= 5*n); heevx( jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, traits::vector_storage (work.first.w_), traits::vector_size (work.first.w_), @@ -260,9 +260,9 @@ R abstol, int& m, R* w, T* z, int const ldz, std::pair, detail::workspace1 > work, int* ifail, int& info) { - assert (2*n <= traits::vector_size (work.first.w_)); - assert (7*n <= traits::vector_size (work.first.wr_)); - assert (5*n <= traits::vector_size (work.second.w_)); + assert (traits::vector_size (work.first.w_) >= 2*n); + assert (traits::vector_size (work.first.wr_) >= 7*n); + assert (traits::vector_size (work.second.w_) >= 5*n); heevx( jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, traits::vector_storage (work.first.w_), traits::vector_size (work.first.w_), @@ -276,7 +276,6 @@ template inline int heevx ( char jobz, char range, A& a, T vl, T vu, int il, int iu, T abstol, int& m, - //char jobz, char range, char uplo, A& a, T vl, T vu, int il, int iu, T abstol, int& m, W& w, Z& z, IFail& ifail, Work work = optimal_workspace() ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK @@ -294,7 +293,7 @@ int const n = traits::matrix_size1 (a); assert (traits::matrix_size2 (a)==n); assert (traits::vector_size (w)==n); - assert (n == traits::vector_size (ifail)); + assert (traits::vector_size (ifail) == n); assert ( range=='A' || range=='V' || range=='I' ); char uplo = traits::matrix_uplo_tag (a); assert ( uplo=='U' || uplo=='L' ); diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/lapack.h /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/lapack.h --- ./boost/numeric/bindings/lapack/lapack.h 2008-06-10 13:05:08.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/lapack.h 2008-06-10 12:32:19.000000000 -0400 @@ -10,8 +10,6 @@ * University of Zagreb, Croatia. * */ -/* Modified to include xPPTRI by Kian Ming A. Chai (14 May 2008) */ - #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H @@ -136,12 +134,6 @@ dcomplex_t const* ap, dcomplex_t* b, int const* ldb, int* info); - void LAPACK_SPPTRI (char const* uplo, int const* n, float* ap, int* info); - void LAPACK_DPPTRI (char const* uplo, int const* n, double* ap, int* info); - void LAPACK_CPPTRI (char const* uplo, int const* n, - fcomplex_t* ap, int* info); - void LAPACK_ZPPTRI (char const* uplo, int const* n, - dcomplex_t* ap, int* info); /* symmetric/Hermitian indefinite and complex symmetric */ @@ -268,15 +260,6 @@ dcomplex_t const* ap, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); - /* banded */ - - void LAPACK_DGBTRF (int const* n, int const* m, int const* kl, int const* ku, - double* ab, int const* ldab, int* ipiv, int* info); - - void LAPACK_DGBTRS (char const* trans, int const* n, int const* kl, int const* ku, int const* nrhs, - double const* ab, int const* ldab, int const* ipiv, - double* b, int const* ldb, int* info); - /**********************************************************************/ /* eigenproblems */ @@ -341,22 +324,51 @@ int* info ); - void LAPACK_SHSEQR( const char* job, const char* compz, const int* n, - const int* ilo, const int* ihi, float* H, - const int* ldH, float* wr, float* wi, fcomplex_t* Z, - const int* ldz, float* work, const int* lwork, int* info); - void LAPACK_DHSEQR( const char* job, const char* compz, const int* n, - const int* ilo, const int* ihi, double* H, - const int* ldH, double* wr, double* wi, dcomplex_t* Z, - const int* ldz, double* work, const int* lwork, int* info); - void LAPACK_CHSEQR( const char* job, const char* compz, const int* n, - const int* ilo, const int* ihi, fcomplex_t* H, const int* ldH, - fcomplex_t* w, fcomplex_t* Z, const int* ldz, - fcomplex_t* work, const int* lwork, int* info); - void LAPACK_ZHSEQR( const char* job, const char* compz, const int* n, - const int* ilo, const int* ihi, dcomplex_t* H, const int* ldH, - dcomplex_t* w, dcomplex_t* Z, const int* ldz, - dcomplex_t* work, const int* lwork, int* info); + void LAPACK_SSYEVD( const char* jobz, const char* uplo, const int* n, + float* a, const int* lda, float* w, + float* work, const int* lwork, + int* iwork, const int* liwork, int* info); + + void LAPACK_DSYEVD( const char* jobz, const char* uplo, const int* n, + double* a, const int* lda, double* w, + double* work, const int* lwork, + int* iwork, const int* liwork, int* info); + + void LAPACK_CHEEVD( const char* jobz, const char* uplo, const int* n, + fcomplex_t* a, const int* lda, float* w, + fcomplex_t* work, const int* lwork, float* rwork, const int* lrwork, + int* iwork, const int* liwork, int* info); + + void LAPACK_ZHEEVD( const char* jobz, const char* uplo, const int* n, + dcomplex_t* a, const int* lda, double* w, + dcomplex_t* work, const int* lwork, double* rwork, const int* lrwork, + int* iwork, const int* liwork, int* info); + + + void LAPACK_SSYEVX( const char* jobz, const char* range, const char* uplo, const int* n, + float* a, const int* lda, const float* vl, const float* vu, const int* il, const int* iu, + const float* abstol, int* m, float* w, float* z, const int* ldz, + float* work, const int* lwork, + int* iwork, int* ifail, int* info); + + void LAPACK_DSYEVX( const char* jobz, const char* range, const char* uplo, const int* n, + double* a, const int* lda, const double* vl, const double* vu, const int* il, const int* iu, + const double* abstol, int* m, double* w, double* z, const int* ldz, + double* work, const int* lwork, + int* iwork, int* ifail, int* info); + + void LAPACK_CHEEVX( const char* jobz, const char* range, const char* uplo, const int* n, + fcomplex_t* a, const int* lda, const float* vl, const float* vu, const int* il, const int* iu, + const float* abstol, int* m, float* w, fcomplex_t* z, const int* ldz, + fcomplex_t* work, const int* lwork, float* rwork, + int* iwork, int* ifail, int* info); + + void LAPACK_ZHEEVX( const char* jobz, const char* range, const char* uplo, const int* n, + dcomplex_t* a, const int* lda, const double* vl, const double* vu, const int* il, const int* iu, + const double* abstol, int* m, double* w, dcomplex_t* z, const int* ldz, + dcomplex_t* work, const int* lwork, double* rwork, + int* iwork, int* ifail, int* info); + void LAPACK_CTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, fcomplex_t* t, const int * ldt, fcomplex_t* vl, const int* ldvl, @@ -395,6 +407,23 @@ dcomplex_t* t, const int * ldt, dcomplex_t* q, const int* ldq, int* ifst, const int * ilst, int* info ); + /* Hessenberg matrices */ + + void LAPACK_SHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, float* H, + const int* LDH, float* WR, float* WI, float* Z, int const* LDZ, + float* WORK, const int* LWORK, int* INFO ) ; + + void LAPACK_CHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, fcomplex_t* H, + const int* LDH, fcomplex_t* W, fcomplex_t* Z, int const* LDZ, + fcomplex_t* WORK, const int* LWORK, int* INFO ) ; + + void LAPACK_DHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, double* H, + const int* LDH, double* WR, double* WI, double* Z, int const* LDZ, + double* WORK, const int* LWORK, int* INFO ) ; + + void LAPACK_ZHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, dcomplex_t* H, + const int* LDH, dcomplex_t* W, dcomplex_t* Z, int const* LDZ, + dcomplex_t* WORK, const int* LWORK, int* INFO ) ; /* Hermitian tridiagonal matrices */ @@ -421,51 +450,6 @@ dcomplex_t* z, int const* ldz, dcomplex_t* work, double* rwork, int* info ); - /* divide and conqer drivers for eigenvalue problems */ - void LAPACK_SSYEVD( const char* jobz, const char* uplo, const int* n, - float* a, const int* lda, float* w, - float* work, const int* lwork, - int* iwork, const int* liwork, int* info); - - void LAPACK_DSYEVD( const char* jobz, const char* uplo, const int* n, - double* a, const int* lda, double* w, - double* work, const int* lwork, - int* iwork, const int* liwork, int* info); - - void LAPACK_CHEEVD( const char* jobz, const char* uplo, const int* n, - fcomplex_t* a, const int* lda, float* w, - fcomplex_t* work, const int* lwork, float* rwork, const int* lrwork, - int* iwork, const int* liwork, int* info); - - void LAPACK_ZHEEVD( const char* jobz, const char* uplo, const int* n, - dcomplex_t* a, const int* lda, double* w, - dcomplex_t* work, const int* lwork, double* rwork, const int* lrwork, - int* iwork, const int* liwork, int* info); - - /* selective eignvector computation */ - void LAPACK_SSYEVX( const char* jobz, const char* range, const char* uplo, const int* n, - float* a, const int* lda, const float* vl, const float* vu, const int* il, const int* iu, - const float* abstol, int* m, float* w, float* z, const int* ldz, - float* work, const int* lwork, - int* iwork, int* ifail, int* info); - - void LAPACK_DSYEVX( const char* jobz, const char* range, const char* uplo, const int* n, - double* a, const int* lda, const double* vl, const double* vu, const int* il, const int* iu, - const double* abstol, int* m, double* w, double* z, const int* ldz, - double* work, const int* lwork, - int* iwork, int* ifail, int* info); - - void LAPACK_CHEEVX( const char* jobz, const char* range, const char* uplo, const int* n, - fcomplex_t* a, const int* lda, const float* vl, const float* vu, const int* il, const int* iu, - const float* abstol, int* m, float* w, fcomplex_t* z, const int* ldz, - fcomplex_t* work, const int* lwork, float* rwork, - int* iwork, int* ifail, int* info); - - void LAPACK_ZHEEVX( const char* jobz, const char* range, const char* uplo, const int* n, - dcomplex_t* a, const int* lda, const double* vl, const double* vu, const int* il, const int* iu, - const double* abstol, int* m, double* w, dcomplex_t* z, const int* ldz, - dcomplex_t* work, const int* lwork, double* rwork, - int* iwork, int* ifail, int* info); void LAPACK_SSBEVX( char const* jobz, char const* range, char const* uplo, int const* n, int const* kd, float* ab, int const* ldab, float* q, int const* ldq, @@ -496,7 +480,6 @@ int* iwork, int* ifail, int* info ); - /*********************************************************************/ /* Auxiliary routines for eigenvalue problems */ /*********************************************************************/ @@ -507,19 +490,6 @@ void LAPACK_DSYTRD( char const* uplo, int const* n, double* a, int const* lda, double* d, double* e, double* tau, double* work, int const* lwork, int* INFO ) ; - - /* Generalized eigenvalue/ eigenvector */ - void LAPACK_SSYGV(int const *itype, char const *jobz, char const *uplo, int const *n, - float *a, int const *lda, float *b, int const *ldb, - float *w, float *work, int const *lwork, int const *info); - - void LAPACK_DSYGV(int const *itype, char const* jobz, char const *uplo, int const * n, - double *a, int const *lda, double *b, int const *ldb, - double *w, double *work, int const *lwork, int const *info); - - - - /*********************************************************************/ /* SVD */ /*********************************************************************/ @@ -610,76 +580,6 @@ const int* lwork, int* info ); - // generates an M-by-N real matrix Q with orthonormal columns, - // which is defined as the first N columns of a product of K elementary - // reflectors of order M - // Q = H(1) H(2) . . . H(k) - void LAPACK_SORGQR(const int *m, const int *n, const int *k, float *a, - const int *lda, float *tau, - float *work, const int *lwork, const int *info); - void LAPACK_DORGQR(const int *m, const int *n, const int *k, - double *a, const int *lda, double *tau, - double *work, const int *lwork, const int *info); - - - /********************************************************************/ - /* Least Squares */ - /********************************************************************/ - - void LAPACK_SGELS(const char* trans, const int* m, const int* n, - const int *nrhs, float* a, const int* lda, - float* b, const int* ldb, float* work, - const int* lwork, int* info); - void LAPACK_DGELS(const char* trans, const int* m, const int* n, - const int *nrhs, double* a, const int* lda, - double* b, const int* ldb, double* work, - const int* lwork, int* info); - void LAPACK_CGELS(const char* trans, const int* m, const int* n, - const int *nrhs, fcomplex_t* a, const int* lda, - fcomplex_t* b, const int* ldb, fcomplex_t* work, - const int* lwork, int* info); - void LAPACK_ZGELS(const char* trans, const int* m, const int* n, - const int *nrhs, dcomplex_t* a, const int* lda, - dcomplex_t* b, const int* ldb, dcomplex_t* work, - const int* lwork, int* info); - - - void LAPACK_SGELSS(const int *m, const int *n, const int *nrhs, - float *a, const int *lda, float *b, const int *ldb, - float *s, const float *rcond, int *rank, float *work, - const int *lwork, int *info); - void LAPACK_DGELSS(const int *m, const int *n, const int *nrhs, - double *a, const int *lda, double *b, const int *ldb, - double *s, const double *rcond, int *rank, double *work, - const int *lwork, int *info); - void LAPACK_CGELSS(const int *m, const int *n, const int *nrhs, - fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb, - float *s, const float *rcond, int *rank, fcomplex_t *work, - const int *lwork, float *rwork, int *info); - void LAPACK_ZGELSS(const int *m, const int *n, const int *nrhs, - dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb, - double *s, const double *rcond, int *rank, dcomplex_t *work, - const int *lwork, double *rwork, int *info); - - - void LAPACK_SGELSD(const int *m, const int *n, const int *nrhs, - float *a, const int *lda, float *b, const int *ldb, - float *s, const float *rcond, int *rank, float *work, - const int *lwork, int *iwork, int *info); - void LAPACK_DGELSD(const int *m, const int *n, const int *nrhs, - double *a, const int *lda, double *b, const int *ldb, - double *s, const double *rcond, int *rank, double *work, - const int *lwork, int *iwork, int *info); - void LAPACK_CGELSD(const int *m, const int *n, const int *nrhs, - fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb, - float *s, const float *rcond, int *rank, fcomplex_t *work, - const int *lwork, float *rwork, int *iwork, int *info); - void LAPACK_ZGELSD(const int *m, const int *n, const int *nrhs, - dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb, - double *s, const double *rcond, int *rank, dcomplex_t *work, - const int *lwork, double *rwork, int *iwork, int *info); - - /********************************************************************/ /* auxiliary */ diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/lapack.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/lapack.hpp --- ./boost/numeric/bindings/lapack/lapack.hpp 2008-04-07 16:03:32.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/lapack.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -33,19 +33,16 @@ #include #include #include -#include // SVD #include #include -#include // Miscellaneous -// QR + #include #include -#include diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/lapack_names.h /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/lapack_names.h --- ./boost/numeric/bindings/lapack/lapack_names.h 2008-06-10 13:05:26.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/lapack_names.h 2008-06-10 12:32:19.000000000 -0400 @@ -44,6 +44,7 @@ #define LAPACK_CGETRI FORTRAN_ID( cgetri ) #define LAPACK_ZGETRI FORTRAN_ID( zgetri ) + /* symmetric/Hermitian positive definite */ #define LAPACK_SPOSV FORTRAN_ID( sposv ) @@ -137,11 +138,6 @@ #define LAPACK_CHPTRS FORTRAN_ID( chptrs ) #define LAPACK_ZHPTRS FORTRAN_ID( zhptrs ) -/* banded solve */ - -#define LAPACK_DGBTRF FORTRAN_ID( dgbtrf ) -#define LAPACK_DGBTRS FORTRAN_ID( dgbtrs ) - /********************************************/ /* eigenproblems */ @@ -161,10 +157,16 @@ #define LAPACK_CHEEV FORTRAN_ID( cheev ) #define LAPACK_ZHEEV FORTRAN_ID( zheev ) -#define LAPACK_SHSEQR FORTRAN_ID( shseqr ) -#define LAPACK_DHSEQR FORTRAN_ID( dhseqr ) -#define LAPACK_CHSEQR FORTRAN_ID( chseqr ) -#define LAPACK_ZHSEQR FORTRAN_ID( zhseqr ) +#define LAPACK_SSYEVD FORTRAN_ID( ssyevd ) +#define LAPACK_DSYEVD FORTRAN_ID( dsyevd ) +#define LAPACK_CHEEVD FORTRAN_ID( cheevd ) +#define LAPACK_ZHEEVD FORTRAN_ID( zheevd ) + +#define LAPACK_SSYEVX FORTRAN_ID( ssyevx ) +#define LAPACK_DSYEVX FORTRAN_ID( dsyevx ) +#define LAPACK_CHEEVX FORTRAN_ID( cheevx ) +#define LAPACK_ZHEEVX FORTRAN_ID( zheevx ) + #define LAPACK_STREVC FORTRAN_ID( strevc ) #define LAPACK_DTREVC FORTRAN_ID( dtrevc ) @@ -176,26 +178,14 @@ #define LAPACK_CTREXC FORTRAN_ID( ctrexc ) #define LAPACK_ZTREXC FORTRAN_ID( ztrexc ) -// generalized eigenvalue/eigenvector -#define LAPACK_SSYGV FORTRAN_ID( ssygv ) -#define LAPACK_DSYGV FORTRAN_ID( dsygv ) - -#define LAPACK_SSYEVD FORTRAN_ID( ssyevd ) -#define LAPACK_DSYEVD FORTRAN_ID( dsyevd ) -#define LAPACK_CHEEVD FORTRAN_ID( cheevd ) -#define LAPACK_ZHEEVD FORTRAN_ID( zheevd ) - -#define LAPACK_SSYEVX FORTRAN_ID( ssyevx ) -#define LAPACK_DSYEVX FORTRAN_ID( dsyevx ) -#define LAPACK_CHEEVX FORTRAN_ID( cheevx ) -#define LAPACK_ZHEEVX FORTRAN_ID( zheevx ) - -#define LAPACK_SSBEVX FORTRAN_ID( ssbevx ) -#define LAPACK_DSBEVX FORTRAN_ID( dsbevx ) -#define LAPACK_CHBEVX FORTRAN_ID( chbevx ) -#define LAPACK_ZHBEVX FORTRAN_ID( zhbevx ) +/********************************************/ +/* eigenproblems for Hessenberg matrices */ +#define LAPACK_SHSEQR FORTRAN_ID( shseqr ) +#define LAPACK_DHSEQR FORTRAN_ID( dhseqr ) +#define LAPACK_CHSEQR FORTRAN_ID( chseqr ) +#define LAPACK_ZHSEQR FORTRAN_ID( zhseqr ) /********************************************/ /* eigenproblems for banded matrices */ @@ -205,6 +195,11 @@ #define LAPACK_CHBEV FORTRAN_ID( chbev ) #define LAPACK_ZHBEV FORTRAN_ID( zhbev ) +#define LAPACK_SSBEVX FORTRAN_ID( ssbevx ) +#define LAPACK_DSBEVX FORTRAN_ID( dsbevx ) +#define LAPACK_CHBEVX FORTRAN_ID( chbevx ) +#define LAPACK_ZHBEVX FORTRAN_ID( zhbevx ) + /********************************************/ /* eigenproblems for tridiagonal matrices */ @@ -231,15 +226,6 @@ #define LAPACK_SSYTRD FORTRAN_ID( ssytrd ) #define LAPACK_DSYTRD FORTRAN_ID( dsytrd ) -// generates an M-by-N real matrix Q with orthonormal columns, -// which is defined as the first N columns of a product of K elementary -// reflectors of order M -// Q = H(1) H(2) . . . H(k) - -#define LAPACK_SORGQR FORTRAN_ID( sorgqr ) -#define LAPACK_DORGQR FORTRAN_ID( dorgqr ) - - /********************************************/ /* SVD */ @@ -256,24 +242,6 @@ /********************************************/ -/* Least Squares */ - -#define LAPACK_SGELS FORTRAN_ID( sgels ) -#define LAPACK_DGELS FORTRAN_ID( dgels ) -#define LAPACK_CGELS FORTRAN_ID( cgels ) -#define LAPACK_ZGELS FORTRAN_ID( zgels ) - -#define LAPACK_SGELSS FORTRAN_ID( sgelss ) -#define LAPACK_DGELSS FORTRAN_ID( dgelss ) -#define LAPACK_CGELSS FORTRAN_ID( cgelss ) -#define LAPACK_ZGELSS FORTRAN_ID( zgelss ) - -#define LAPACK_SGELSD FORTRAN_ID( sgelsd ) -#define LAPACK_DGELSD FORTRAN_ID( dgelsd ) -#define LAPACK_CGELSD FORTRAN_ID( cgelsd ) -#define LAPACK_ZGELSD FORTRAN_ID( zgelsd ) - -/********************************************/ /* auxiliary */ #define LAPACK_ILAENV FORTRAN_ID( ilaenv ) diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/orgqr.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/orgqr.hpp --- ./boost/numeric/bindings/lapack/orgqr.hpp 2008-04-11 10:08:16.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/orgqr.hpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,156 +0,0 @@ -// -// Copyright Fabien Dekeyser, Quoc-Cuong Pham 2008 -// -// 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) -// - -/** - * - * \brief Generates an M-by-N real matrix Q with orthonormal columns, - * which is defined as the first N columns of a product of K elementary - * reflectors of order M - * Q = H(1) H(2) . . . H(k) - * - * \warning - * \todo - * \date 2005 - * \author CEA/DRT/DTSI/SARC - * \author Q.C. PHAM - * - **/ - - -#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORGQR_HPP -#define BOOST_NUMERIC_BINDINGS_LAPACK_ORGQR_HPP - -#include -#include -#include -#include -#include -// #include - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK -# include -# include -#endif - - -namespace boost { namespace numeric { namespace bindings { - - namespace lapack { - - - /////////////////////////////////////////////////////////////////// - /* - * Generates an M-by-N real matrix Q with orthonormal columns, - * which is defined as the first N columns of a product of K elementary - * reflectors of order M - * Q = H(1) H(2) . . . H(k) - * as returned by geqrf(). - * The init value of matrix Q is the matrix A returned by geqrf() - */ - /////////////////////////////////////////////////////////////////// - namespace detail { - - - inline - void orgqr(int const m, int const n, int const k, - float* a, int const lda, - float* tau, float* work, int const lwork, int& info) - { - LAPACK_SORGQR (&m, &n, &k, a, &lda, tau, work, &lwork, &info); - } - - inline - void orgqr(int const m, int const n, int const k, - double* a, int const lda, - double* tau, double* work, int const lwork, int& info) - { - LAPACK_DORGQR (&m, &n, &k, a, &lda, tau, work, &lwork, &info); - } - - } // fin namespace detail - - - //-------------------------------------------- - - template - inline int orgqr(A& a, Tau& tau, Work &work) { - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK - BOOST_STATIC_ASSERT((boost::is_same< - typename traits::matrix_traits::matrix_structure, - traits::general_t - >::value)); -#endif - - const int m = traits::matrix_size1 (a); - const int n = traits::matrix_size2 (a); - const int k = n; - - assert (std::min(m,n) <= traits::vector_size (tau)); - assert (n <= traits::vector_size (work)); - - int info; - detail::orgqr (m, n, k, - traits::matrix_storage (a), - traits::leading_dimension (a), - traits::vector_storage (tau), - traits::vector_storage (work), - traits::vector_size (work), - info); - return info; - } - - // Computation of Q. - // Workspace is allocated dynamically so that the optimization of - // blas 3 calls is optimal. - template - inline - int orgqr (A& a, Tau& tau, optimal_workspace ) { - typedef typename A::value_type value_type ; - const int n = traits::matrix_size2 (a); - traits::detail::array work(std::max(1, n*32)); - return orgqr( a, tau, work ); - - } - - // Computation of Q - // Workspace is allocated dynamically to its minimum size. - // Blas 3 calls are not optimal. - template - inline - int orgqr (A& a, Tau& tau, minimal_workspace ) { - typedef typename A::value_type value_type ; - const int n = traits::matrix_size2 (a); - traits::detail::array work(std::max(1, n)); - return orgqr( a, tau, work ); - } - - // Computation of the Q - // Workspace is taken from the array in workspace. - - template - inline - int orgqr (A& a, Tau& tau, detail::workspace1 workspace ) { - typedef typename A::value_type value_type ; - const int n = traits::matrix_size2 (a); - traits::detail::array work(std::max(1, n)); - return orgqr( a, tau, workspace.w_ ); - } - - // Function without workarray as argument - template - inline - int orgqr (A& a, Tau& tau) { - return orgqr( a, tau, optimal_workspace() ); - } - - } - -}}} - -#endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/ppsv.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/ppsv.hpp --- ./boost/numeric/bindings/lapack/ppsv.hpp 2008-06-10 13:06:53.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/ppsv.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -10,7 +10,6 @@ * University of Zagreb, Croatia. * */ -/* Modified to include xPPTRI by Kian Ming A. Chai (14 May 2008) */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP @@ -264,62 +263,7 @@ return info; } - - /* - * pptri() computes the inverse of a real symmetric positive definite - * matrix A using the Cholesky factorization A = U**T*U or A = L*L**T - * computed by pptrf(). - */ - - namespace detail { - - inline - void pptri (char const uplo, int const n, float* ap, int* info) { - LAPACK_SPPTRI (&uplo, &n, ap, info); - } - - inline - void pptri (char const uplo, int const n, double* ap, int* info) { - LAPACK_DPPTRI (&uplo, &n, ap, info); - } - - inline - void pptri (char const uplo, int const n, - traits::complex_f* ap, int* info) - { - LAPACK_CPPTRI (&uplo, &n, traits::complex_ptr (ap), info); - } - - inline - void pptri (char const uplo, int const n, - traits::complex_d* ap, int* info) - { - LAPACK_ZPPTRI(&uplo, &n, traits::complex_ptr (ap), info); - } - - } - - template - inline - int pptri (SymmMatrA& a) { //ISSUE: More correctly, triangular matrix - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK - BOOST_STATIC_ASSERT((boost::is_same< - typename traits::matrix_traits::matrix_structure, - typename traits::detail::symm_herm_pack_t< - typename traits::matrix_traits::value_type - >::type - >::value)); -#endif - - int const n = traits::matrix_size1 (a); - assert (n == traits::matrix_size2 (a)); - char uplo = traits::matrix_uplo_tag (a); - int info; - detail::pptri (uplo, n, traits::matrix_storage (a), &info); - return info; - } - + // TO DO: pptri() } diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/syev.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/syev.hpp --- ./boost/numeric/bindings/lapack/syev.hpp 2008-06-10 12:58:08.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/syev.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -114,7 +114,7 @@ int const n = traits::matrix_size1 (a); - traits::detail::array work( std::max(1,34*n) ); + traits::detail::array work( std::max(1,34*n) ); return detail::syev(jobz, uplo, a, w, work); } // syev() @@ -127,7 +127,7 @@ int const n = traits::matrix_size1 (a); - traits::detail::array work( std::max(1,3*n-1) ); + traits::detail::array work( std::max(1,3*n-1) ); return detail::syev(jobz, uplo, a, w, work); } // syev() @@ -141,13 +141,6 @@ return detail::syev(jobz, uplo, a, w, workspace.w_); } // syev() - // Function without workarray as argument - template - inline - int syev (char jobz, char uplo, A& a, W& w) { - return syev(jobz, uplo, a, w, optimal_workspace()); - } // syev() - } }}} diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/lapack/sygv.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/sygv.hpp --- ./boost/numeric/bindings/lapack/sygv.hpp 2008-04-11 10:08:36.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/lapack/sygv.hpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,231 +0,0 @@ -// -// Copyright Fabien Dekeyser, Quoc-Cuong Pham 2008 -// -// 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) -// - -#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYGV_HPP -#define BOOST_NUMERIC_BINDINGS_LAPACK_SYGV_HPP - -#include -#include -#include -#include -// #include - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK -# include -# include -#endif - -#include - - -namespace boost { namespace numeric { namespace bindings { - - namespace lapack { - - /////////////////////////////////////////////////////////////////// - // - // sygv - // - /////////////////////////////////////////////////////////////////// - - /* - * sygv() computes all the eigenvalues, and optionally, the eigenvectors - * of a real generalized symmetric-definite eigenproblem, of the form - * A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. - * Here A and B are assumed to be symmetric and B is also - * positive definite. - * TYPE (input) INTEGER - * Specifies the problem type to be solved: - * = 1: A*x = (lambda)*B*x - * = 2: A*B*x = (lambda)*x - * = 3: B*A*x = (lambda)*x - * - * JOBZ (input) CHARACTER*1 - * = 'N': Compute eigenvalues only; - * = 'V': Compute eigenvalues and eigenvectors. - * - * UPLO (input) CHARACTER*1 - * = 'U': Upper triangles of A and B are stored; - * = 'L': Lower triangles of A and B are stored. - * - * N (input) INTEGER - * The order of the matrices A and B. N >= 0. - * - * A (input/output) DOUBLE PRECISION array, dimension (LDA, N) - * On entry, the symmetric matrix A. If UPLO = 'U', the - * leading N-by-N upper triangular part of A contains the - * upper triangular part of the matrix A. If UPLO = 'L', - * the leading N-by-N lower triangular part of A contains - * the lower triangular part of the matrix A. - * - * On exit, if JOBZ = 'V', then if INFO = 0, A contains the - * matrix Z of eigenvectors. The eigenvectors are normalized - * as follows: - * if ITYPE = 1 or 2, Z**T*B*Z = I; - * if ITYPE = 3, Z**T*inv(B)*Z = I. - * If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') - * or the lower triangle (if UPLO='L') of A, including the - * diagonal, is destroyed. - * - * LDA (input) INTEGER - * The leading dimension of the array A. LDA >= max(1,N). - * - * B (input/output) DOUBLE PRECISION array, dimension (LDB, N) - * On entry, the symmetric positive definite matrix B. - * If UPLO = 'U', the leading N-by-N upper triangular part of B - * contains the upper triangular part of the matrix B. - * If UPLO = 'L', the leading N-by-N lower triangular part of B - * contains the lower triangular part of the matrix B. - * - * On exit, if INFO <= N, the part of B containing the matrix is - * overwritten by the triangular factor U or L from the Cholesky - * factorization B = U**T*U or B = L*L**T. - * - * LDB (input) INTEGER - * The leading dimension of the array B. LDB >= max(1,N). - * - * W (output) DOUBLE PRECISION array, dimension (N) - * If INFO = 0, the eigenvalues in ascending order. - * - * WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK)) - * On exit, if INFO = 0, WORK(1) returns the optimal LWORK. - * - * LWORK (input) INTEGER - * The length of the array WORK. LWORK >= max(1,3*N-1). - * For optimal efficiency, LWORK >= (NB+2)*N, - * where NB is the blocksize for DSYTRD returned by ILAENV. - * - * If LWORK = -1, then a workspace query is assumed; the routine - * only calculates the optimal size of the WORK array, returns - * this value as the first entry of the WORK array, and no error - * message related to LWORK is issued by XERBLA. - * - * INFO (output) INTEGER - * = 0: successful exit - * < 0: if INFO = -i, the i-th argument had an illegal value - * > 0: DPOTRF or DSYEV returned an error code: - * <= N: if INFO = i, DSYEV failed to converge; - * i off-diagonal elements of an intermediate - * tridiagonal form did not converge to zero; - * > N: if INFO = N + i, for 1 <= i <= N, then the leading - * minor of order i of B is not positive definite. - * The factorization of B could not be completed and - * no eigenvalues or eigenvectors were computed. - * - */ - - namespace detail { - - inline - void sygv (int const itype, char const jobz, char const uplo, int const n, - float *a, int const lda, float *b, int const ldb, - float *w, float *work, int const lwork, int& info) - { - - LAPACK_SSYGV (&itype, &jobz, &uplo, &n, a, &lda, b, &ldb, w, work, &lwork, &info); - } - - inline - void sygv (int const itype, char const jobz, char const uplo, int const n, - double *a, int const lda, double *b, int const ldb, - double *w, double *work, int const lwork, int& info) - { - LAPACK_DSYGV (&itype, &jobz, &uplo, &n, a, &lda, b, &ldb, w, work, &lwork, &info); - } - - - template - inline - int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w, Work& work) { - -#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK - BOOST_STATIC_ASSERT((boost::is_same< - typename traits::matrix_traits::matrix_structure, - traits::general_t - >::value)); -#endif - - int const n = traits::matrix_size1 (a); - assert ( n>0 ); - assert (traits::matrix_size2 (a)==n); - assert (traits::leading_dimension (a)>=n); - assert (traits::vector_size (w)==n); - assert (3*n-1 <= traits::vector_size (work)); - - int const nb = traits::matrix_size1 (b); - assert ( nb>0 ); - assert (traits::matrix_size2 (b)==nb); - assert (traits::leading_dimension (b)>=nb); - assert ( n== nb); - - assert ( uplo=='U' || uplo=='L' ); - assert ( jobz=='N' || jobz=='V' ); - - assert( itype==1 || itype==2 || itype==3); - - - int info; - detail::sygv (itype, jobz, uplo, n, - traits::matrix_storage (a), - traits::leading_dimension (a), - traits::matrix_storage (b), - traits::leading_dimension (b), - traits::vector_storage (w), - traits::vector_storage (work), - traits::vector_size (work), - info); - return info; - } - } // namespace detail - - - // Function that allocates work arrays - template - inline - int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w, optimal_workspace ) { - typedef typename A::value_type value_type ; - - int const n = traits::matrix_size1 (a); - traits::detail::array work( std::max(1,34*n) ); - return detail::sygv(itype, jobz, uplo, a, b, w, work); - } // sygv() - - - // Function that allocates work arrays - template - inline - int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w, minimal_workspace ) { - typedef typename A::value_type value_type ; - - int const n = traits::matrix_size1 (a); - - traits::detail::array work( std::max(1,3*n-1) ); - return detail::sygv(itype, jobz, uplo, a, b, w, work); - } // sygv() - - - // Function that allocates work arrays - template - inline - int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w, detail::workspace1 workspace ) { - typedef typename A::value_type value_type ; - - return detail::sygv(itype, jobz, uplo, a, b, w, workspace.w_); - } // sygv() - - template - inline - int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w) { - return sygv(itype, jobz, uplo, a, b, w, optimal_workspace()); - } // sygv() - - } - -}}} - -#endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/traits/detail/ublas_ordering.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/traits/detail/ublas_ordering.hpp --- ./boost/numeric/bindings/traits/detail/ublas_ordering.hpp 2008-06-10 12:58:08.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/traits/detail/ublas_ordering.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -92,17 +92,17 @@ template static int leading_dimension( M const& m ) { - return m.lower() + m.upper() + 1 ; + return m.size2() ; } template static int stride1( M const& m ) { - return std::max(m.size1(), m.size2()) ; + return leading_dimension(m) ; } template static int stride2( M const& m ) { - return 1 ; + return 1-leading_dimension(m) ; } }; } diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/traits/ublas_banded.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/traits/ublas_banded.hpp --- ./boost/numeric/bindings/traits/ublas_banded.hpp 2008-06-10 12:58:08.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/traits/ublas_banded.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -71,9 +71,6 @@ static int upper_bandwidth (matrix_type& m) { return m.upper() ; } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { - // g++ 2.95.4 and 3.0.4 (with -pedantic) dislike - // identifier_type::functor_type::size2() - //return lower_bandwidth(m) + upper_bandwidth(m) + 1 ; typedef typename identifier_type::orientation_category orientation_category; return detail::ublas_banded_ordering::leading_dimension(m) ; } @@ -81,15 +78,11 @@ // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { typedef typename identifier_type::orientation_category orientation_category; - //typedef typename detail::ublas_ordering::functor_type functor_t ; - //return functor_t::one2 ( std::max(m.size1(), m.size2()), leading_dimension(m)-1 ) ; return detail::ublas_banded_ordering::stride1(m) ; } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { typedef typename identifier_type::orientation_category orientation_category; - //typedef typename detail::ublas_ordering::functor_type functor_t ; - //return functor_t::one1 ( std::max(m.size1(), m.size2()), leading_dimension(m)-1 ) ; return detail::ublas_banded_ordering::stride2(m) ; } }; diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./boost/numeric/bindings/umfpack/umfpack_inc.hpp /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/umfpack/umfpack_inc.hpp --- ./boost/numeric/bindings/umfpack/umfpack_inc.hpp 2008-06-10 12:58:08.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/boost/numeric/bindings/umfpack/umfpack_inc.hpp 2008-06-10 12:32:19.000000000 -0400 @@ -53,7 +53,7 @@ #define BOOST_NUMERIC_BINDINGS_UMFPACK_INC_H extern "C" { -#include +#include } #endif diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./configure /home/andreas/tmp/boost-sandbox/configure --- ./configure 2007-08-26 13:57:09.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/configure 1969-12-31 19:00:00.000000000 -0500 @@ -1,62 +0,0 @@ -#! /usr/bin/env python - - - - - -def var_to_option(caps_name): - return caps_name.lower().replace("_", "-") - - - - -def var_kind(caps_name): - last_underscore = caps_name.rfind("_") - return caps_name[last_underscore+1:] - - - - -if __name__ == "__main__": - from optparse import OptionParser - - parser = OptionParser() - parser.add_option("--prefix", default="/usr/local", - help="Where to install the header files") - - options, args = parser.parse_args() - - substitutions = { - "PREFIX": options.prefix - } - - import re - var_re = re.compile(r"\$\{([A-Za-z_0-9]+)\}") - string_var_re = re.compile(r"\$str\{([A-Za-z_0-9]+)\}") - for fname in ["Makefile"]: - lines = open(fname+".in", "r").readlines() - new_lines = [] - for l in lines: - made_change = True - while made_change: - made_change = False - match = var_re.search(l) - if match: - varname = match.group(1) - l = l[:match.start()] + str(substitutions[varname]) + l[match.end():] - made_change = True - - match = string_var_re.search(l) - if match: - varname = match.group(1) - subst = substitutions[varname] - if subst is None: - subst = "" - else: - subst = '"%s"' % subst - - l = l[:match.start()] + subst + l[match.end():] - made_change = True - new_lines.append(l) - - file(fname, "w").write("".join(new_lines)) diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./.gitignore /home/andreas/tmp/boost-sandbox/.gitignore --- ./.gitignore 2008-06-10 12:59:07.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/.gitignore 1969-12-31 19:00:00.000000000 -0500 @@ -1,7 +0,0 @@ -*~ -Makefile -*.swp -*.patch -.svn -*.orig -*.rej diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./libs/numeric/bindings/lapack/test/convenience.h /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/convenience.h --- ./libs/numeric/bindings/lapack/test/convenience.h 2007-08-27 09:16:02.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/convenience.h 1969-12-31 19:00:00.000000000 -0500 @@ -1,254 +0,0 @@ -#ifndef CONVENIENCE_H -#define CONVENIENCE_H - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -namespace ublas = boost::numeric::ublas; -namespace traits = boost::numeric::bindings::traits; - -// single precision typedefs -typedef float freal_t; -typedef ublas::matrix fmat_t; -typedef ublas::vector fvec_t; - -// double precision typedefs -typedef double dreal_t; -typedef ublas::matrix dmat_t; -typedef ublas::vector dvec_t; - -// single precision complex typedefs -typedef std::complex fcmplx_t; -typedef ublas::matrix fcmat_t; -typedef ublas::vector fcvec_t; - -// double precision complex typedefs -typedef std::complex dcmplx_t; -typedef ublas::matrix dcmat_t; -typedef ublas::vector dcvec_t; - -// matrix/vector test sizes -const int row_size = 3; -const int col_size = 3; -const int row_range = 2; -const int col_range = 2; - -////////////////////////////////////////////////////////////////// -// -// Helper functions and structs to aid with testing -// -///////////////////////////////////////////////////////////////// -template -void matrix_print(StreamType& oss, const std::string& name, const MatType& mat) -{ - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - - oss << name << std::endl; - for (int i=0; i < m; ++i) - { - for (int j=0; j < n; ++j) - { - oss << mat(i,j) << std::setw(10); - } - oss << std::setw(0) << std::endl; - } -} - -template -void vector_print(StreamType& oss, const std::string& name, const VecType& vec) -{ - const int m = traits::vector_size(vec); - - oss << name << std::endl; - for (int i=0; i < m; ++i) - { - oss << vec(i) << std::endl; - } -} - -// structs to create matrices for testing -template -struct MatrixGenerator {}; - -template <> -struct MatrixGenerator -{ - typedef fmat_t Result; - inline Result operator() (size_t m, size_t n) - { - Result mat(row_size, col_size); - mat(0,0) = 8.; - mat(0,1) = 1.; - mat(0,2) = 6.; - mat(1,0) = 3.; - mat(1,1) = 5.; - mat(1,2) = 7.; - mat(2,0) = 4.; - mat(2,1) = 9.; - mat(2,2) = 2.; - - return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); - } -}; - -template <> -struct MatrixGenerator -{ - typedef dmat_t Result; - inline Result operator() (size_t m, size_t n) - { - Result mat(row_size, col_size); - mat(0,0) = 8.; - mat(0,1) = 1.; - mat(0,2) = 6.; - mat(1,0) = 3.; - mat(1,1) = 5.; - mat(1,2) = 7.; - mat(2,0) = 4.; - mat(2,1) = 9.; - mat(2,2) = 2.; - - return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); - } -}; - -template <> -struct MatrixGenerator -{ - typedef fcmat_t Result; - inline Result operator() (size_t m, size_t n) - { - typedef Result::value_type val_t; - - Result mat(row_size , col_size); - mat(0,0) = val_t(35.,1.); - mat(0,1) = val_t(6.,26.); - mat(0,2) = val_t(19.,24.); - mat(1,0) = val_t(3.,32.); - mat(1,1) = val_t(7.,21.); - mat(1,2) = val_t(23.,25.); - mat(2,0) = val_t(31.,9.); - mat(2,1) = val_t(2.,22.); - mat(2,2) = val_t(27.,20.); - - return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); - } -}; - -template <> -struct MatrixGenerator -{ - typedef dcmat_t Result; - inline Result operator() (size_t m, size_t n) - { - typedef Result::value_type val_t; - - Result mat(row_size , col_size); - mat(0,0) = val_t(35.,1.); - mat(0,1) = val_t(6.,26.); - mat(0,2) = val_t(19.,24.); - mat(1,0) = val_t(3.,32.); - mat(1,1) = val_t(7.,21.); - mat(1,2) = val_t(23.,25.); - mat(2,0) = val_t(31.,9.); - mat(2,1) = val_t(2.,22.); - mat(2,2) = val_t(27.,20.); - - return Result(ublas::project(mat, ublas::range(0, m), ublas::range(0, n))); - } -}; - - -// structs to create vectors for testing -template -struct VectorGenerator {}; - -template <> -struct VectorGenerator -{ - typedef fvec_t Result; - inline Result operator() (size_t m) - { - typedef Result::value_type val_t; - Result v(m); - - for (size_t i=0; i < m; ++i) - { - val_t val = val_t(i+1); - v(i) = val; - } - - return v; - } -}; - -template <> -struct VectorGenerator -{ - typedef dvec_t Result; - inline Result operator() (size_t m) - { - typedef Result::value_type val_t; - Result v(m); - - for (size_t i=0; i < m; ++i) - { - val_t val = val_t(i+1); - v(i) = val; - } - - return v; - } -}; - -template <> -struct VectorGenerator -{ - typedef fcvec_t Result; - inline Result operator() (size_t m) - { - typedef Result::value_type val_t; - Result v(m); - - for (size_t i=0; i < m; ++i) - { - val_t::value_type val = val_t::value_type(i); - v(i) = val_t(val+1, val+1); - } - - return v; - } -}; - -template <> -struct VectorGenerator -{ - typedef dcvec_t Result; - inline Result operator() (size_t m) - { - typedef Result::value_type val_t; - Result v(m); - - for (size_t i=0; i < m; ++i) - { - val_t::value_type val = val_t::value_type(i); - v(i) = val_t(val+1, val+1); - } - - return v; - } -}; - -#endif \ Kein Zeilenumbruch am Dateiende. diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./libs/numeric/bindings/lapack/test/ublas_gels.cpp /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/ublas_gels.cpp --- ./libs/numeric/bindings/lapack/test/ublas_gels.cpp 2007-08-27 16:07:04.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/ublas_gels.cpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,523 +0,0 @@ - -#include "convenience.h" -#include - -// set to 1 for more output -//#define VERBOSE_OUTPUT 1 - -// set to 1 to write test output to file, otherwise outputs to console -#define OUTPUT_TO_FILE 0 - -// determines which tests to run -#define TEST_SQUARE 1 -#define TEST_UNDERDETERMINED 0 -#define TEST_OVERDETERMINED 0 -#define TEST_MULTIPLE_SOLUTION_VECTORS 0 -#define TEST_TRANSPOSE 0 - -// determines if optimal, minimal, or both workspaces are used for testing -#define USE_OPTIMAL_WORKSPACE 1 -#define USE_MINIMAL_WORKSPACE 0 - -namespace lapack = boost::numeric::bindings::lapack; - -// test function declarations -template -int test_square_gels(StreamType& oss); - -template -int test_under_gels(StreamType& oss); - -template -int test_over_gels(StreamType& oss); - -template -int test_multiple_gels(StreamType& oss); - -template -int test_transpose_gels(StreamType& oss, const char& trans); - -int main() -{ - // stream for test output - typedef std::ostringstream stream_t; - stream_t oss; - -#if TEST_SQUARE - oss << "Start Square Matrix Least Squares Tests" << std::endl; - oss << "Testing sgels" << std::endl; - if (test_square_gels(oss) == 0) - { - oss << "sgels passed." << std::endl; - } - oss << "End sgels tests" << std::endl; - oss << std::endl; - oss << "Testing dgels" << std::endl; - if (test_square_gels(oss) == 0) - { - oss << "dgels passed." << std::endl; - } - oss << "End dgels tests" << std::endl; - oss << std::endl; - oss << "Testing cgels" << std::endl; - if (test_square_gels(oss) == 0) - { - oss << "cgels passed." << std::endl; - } - oss << "End cgels tests" << std::endl; - oss << std::endl; - oss << "Testing zgels" << std::endl; - if (test_square_gels(oss) == 0) - { - oss << "zgels passed." << std::endl; - } - oss << "End zgels tests" << std::endl; - oss << std::endl; - oss << "End Square Matrix Least Squares Tests" << std::endl; -#endif - -#if TEST_UNDERDETERMINED - oss << std::endl; - oss << "Start Under-determined Matrix Least Squares Test" << std::endl; - oss << "Testing sgels" << std::endl; - if (test_under_gels(oss) == 0) - { - oss << "sgels passed." << std::endl; - } - oss << "End sgels tests" << std::endl; - oss << std::endl; - oss << "Testing dgels" << std::endl; - if (test_under_gels(oss) == 0) - { - oss << "dgels passed." << std::endl; - } - oss << "End dgels tests" << std::endl; - oss << std::endl; - oss << "Testing cgels" << std::endl; - if (test_under_gels(oss) == 0) - { - oss << "cgels passed." << std::endl; - } - oss << "End cgels tests" << std::endl; - oss << std::endl; - oss << "Testing zgels" << std::endl; - if (test_under_gels(oss) == 0) - { - oss << "zgels passed." << std::endl; - } - oss << "End zgels tests" << std::endl; - oss << std::endl; - oss << "End Underdetermined Matrix Least Squares Tests" << std::endl; -#endif - -#if TEST_OVERDETERMINED - oss << std::endl; - oss << "Start Overdetermined Matrix Least Squares Test" << std::endl; - oss << "Testing sgels" << std::endl; - if (test_over_gels(oss) == 0) - { - oss << "sgels passed." << std::endl; - } - oss << "End sgels tests" << std::endl; - oss << std::endl; - oss << "Testing dgels" << std::endl; - if (test_over_gels(oss) == 0) - { - oss << "dgels passed." << std::endl; - } - oss << "End dgels tests" << std::endl; - oss << std::endl; - oss << "Testing cgels" << std::endl; - if (test_over_gels(oss) == 0) - { - oss << "cgels passed." << std::endl; - } - oss << "End cgels tests" << std::endl; - oss << std::endl; - oss << "Testing zgels" << std::endl; - if (test_over_gels(oss) == 0) - { - oss << "zgels passed." << std::endl; - } - oss << "End zgels tests" << std::endl; - oss << std::endl; - oss << "End Overdetermined Matrix Least Squares Test" << std::endl; -#endif - -#if TEST_MULTIPLE_SOLUTION_VECTORS - oss << std::endl; - oss << "Start Multiple Solution Vectors Least Squares Test" << std::endl; - oss << "Testing sgels" << std::endl; - if (test_multiple_gels(oss) == 0) - { - oss << "sgels passed." << std::endl; - } - oss << "End sgels tests" << std::endl; - oss << std::endl; - oss << "Testing dgels" << std::endl; - if (test_multiple_gels(oss) == 0) - { - oss << "dgels passed." << std::endl; - } - oss << "End dgels tests" << std::endl; - oss << std::endl; - oss << "Testing cgels" << std::endl; - if (test_multiple_gels(oss) == 0) - { - oss << "cgels passed." << std::endl; - } - oss << "End cgels tests" << std::endl; - oss << std::endl; - oss << "Testing zgels" << std::endl; - if (test_multiple_gels(oss) == 0) - { - oss << "zgels passed." << std::endl; - } - oss << "End zgels tests" << std::endl; - oss << std::endl; - oss << "End Multiple Solution Vectors Least Squares Test" << std::endl; -#endif - -#if TEST_TRANSPOSE - oss << std::endl; - oss << "Start Transpose Least Squares Test" << std::endl; - oss << "Testing sgels" << std::endl; - if (test_transpose_gels(oss, 'T') == 0) - { - oss << "sgels passed." << std::endl; - } - oss << "End sgels tests" << std::endl; - oss << std::endl; - oss << "Testing dgels" << std::endl; - if (test_transpose_gels(oss, 'T') == 0) - { - oss << "dgels passed." << std::endl; - } - oss << "End dgels tests" << std::endl; - oss << std::endl; - oss << "Testing cgels" << std::endl; - if (test_transpose_gels(oss, 'C') == 0) - { - oss << "cgels passed." << std::endl; - } - oss << "End cgels tests" << std::endl; - oss << std::endl; - oss << "Testing zgels" << std::endl; - if (test_transpose_gels(oss, 'C') == 0) - { - oss << "zgels passed." << std::endl; - } - oss << "End zgels tests" << std::endl; - oss << std::endl; - oss << "End Transpose Least Squares Test" << std::endl; -#endif - - // Finished testing - std::cout << std::endl; - std::cout << "Tests Completed." << std::endl; - std::cout << std::endl; - -#if OUTPUT_TO_FILE - std::string filename; - std::cout << "Enter filename to write test results: "; - std::getline(std::cin, filename); - - std::ofstream testFile(filename.c_str()); - - if (testFile) - { - testFile << oss.str(); - testFile.close(); - } -#else - std::cout << oss.str() << std::endl; -#endif - - // wait for user to finish - std::string done; - std::cout << "Press Enter to exit"; - std::getline(std::cin, done); - -} - -// tests square system (m-by-n where m == n) -template -int test_square_gels(StreamType& oss) -{ - // return value - int err = 0; - - // square matrix test - MatType mat(MatrixGenerator()(row_size, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif - - // check A*x=B -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests overdetermined system (m-by-n where m < n) -template -int test_under_gels(StreamType& oss) -{ - // return value - int err = 0; - - // under-determined matrix test - MatType mat(MatrixGenerator()(row_range, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif - - // check A*x=B -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests overdetermined system (m-by-n where m > n) -template -int test_over_gels(StreamType& oss) -{ - // return value - int err = 0; - - // overdetermined matrix test - MatType mat(MatrixGenerator()(row_size, col_range)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif - - // check A*x=B -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests multiple solution vectors stored column-wise in B for equation A*x=B -template -int test_multiple_gels(StreamType& oss) -{ - // return value - int err = 0; - - // multiple solutions vectors test - MatType mat(MatrixGenerator()(row_size, col_size)); - MatType vec(mat.size1(), 2); - ublas::column(vec, 0) = VectorGenerator()(mat.size1()); - ublas::column(vec, 1) = VectorGenerator()(mat.size1()); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - const int nrhs = traits::matrix_size2(vec); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - MatType optimalvec(vec); - err += lapack::gels('N', optimalmat, optimalvec, lapack::optimal_workspace()); - MatType optimalanswer(ublas::project(optimalvec, ublas::range(0, n), ublas::range(0, nrhs))); - MatType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - MatType minimalvec(vec); - err += lapack::gels('N', minimalmat, minimalvec, lapack::minimal_workspace()); - MatType minimalanswer(ublas::project(minimalvec, ublas::range(0, n), ublas::range(0, nrhs))); - MatType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - matrix_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - matrix_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - matrix_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif - - // check A*x=B -#if USE_OPTIMAL_WORKSPACE - matrix_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - matrix_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -template -int test_transpose_gels(StreamType& oss, const char& trans) -{ - // return value - int err = 0; - - // overdetermined matrix test - MatType mat(MatrixGenerator()(row_size, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gels(trans, optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gels(trans, minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif - - // check A*x=B -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} \ Kein Zeilenumbruch am Dateiende. diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./libs/numeric/bindings/lapack/test/ublas_gelsd.cpp /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/ublas_gelsd.cpp --- ./libs/numeric/bindings/lapack/test/ublas_gelsd.cpp 2007-08-27 16:06:42.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/ublas_gelsd.cpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,435 +0,0 @@ - -#include "convenience.h" -#include - -// set to 1 for more output -//#define VERBOSE_OUTPUT 0 - -// set to 1 to write test output to file, otherwise outputs to console -#define OUTPUT_TO_FILE 0 - -// determines which tests to run -#define TEST_SQUARE 1 -#define TEST_UNDERDETERMINED 0 -#define TEST_OVERDETERMINED 0 -#define TEST_MULTIPLE_SOLUTION_VECTORS 0 - -// determines if optimal, minimal, or both workspaces are used for testing -#define USE_OPTIMAL_WORKSPACE 1 -#define USE_MINIMAL_WORKSPACE 0 - -namespace lapack = boost::numeric::bindings::lapack; - -// test function declarations -template -int test_square_gelsd(StreamType& oss); - -template -int test_under_gelsd(StreamType& oss); - -template -int test_over_gelsd(StreamType& oss); - -template -int test_multiple_gelsd(StreamType& oss); - -template -int test_transpose_gel(StreamType& oss, const char& trans); - - -int main() -{ - // stream for test output - typedef std::ostringstream stream_t; - stream_t oss; - -#if TEST_SQUARE - oss << "Start Square Matrix Least Squares Tests" << std::endl; - oss << "Testing sgelsd" << std::endl; - if (test_square_gelsd(oss) == 0) - { - oss << "sgelsd passed." << std::endl; - } - oss << "End sgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing dgelsd" << std::endl; - if (test_square_gelsd(oss) == 0) - { - oss << "dgelsd passed." << std::endl; - } - oss << "End dgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing cgelsd" << std::endl; - if (test_square_gelsd(oss) == 0) - { - oss << "cgelsd passed." << std::endl; - } - oss << "End cgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing zgelsd" << std::endl; - if (test_square_gelsd(oss) == 0) - { - oss << "zgelsd passed." << std::endl; - } - oss << "End zgelsd tests" << std::endl; - oss << std::endl; - oss << "End Square Matrix Least Squares Tests" << std::endl; -#endif - -#if TEST_UNDERDETERMINED - oss << std::endl; - oss << "Start Under-determined Matrix Least Squares Test" << std::endl; - oss << "Testing sgelsd" << std::endl; - if (test_under_gelsd(oss) == 0) - { - oss << "sgelsd passed." << std::endl; - } - oss << "End sgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing dgelsd" << std::endl; - if (test_under_gelsd(oss) == 0) - { - oss << "dgelsd passed." << std::endl; - } - oss << "End dgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing cgelsd" << std::endl; - if (test_under_gelsd(oss) == 0) - { - oss << "cgelsd passed." << std::endl; - } - oss << "End cgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing zgelsd" << std::endl; - if (test_under_gelsd(oss) == 0) - { - oss << "zgelsd passed." << std::endl; - } - oss << "End zgelsd tests" << std::endl; - oss << std::endl; - oss << "End Underdetermined Matrix Least Squares Tests" << std::endl; -#endif - -#if TEST_OVERDETERMINED - oss << std::endl; - oss << "Start Overdetermined Matrix Least Squares Test" << std::endl; - oss << "Testing sgelsd" << std::endl; - if (test_over_gelsd(oss) == 0) - { - oss << "sgelsd passed." << std::endl; - } - oss << "End sgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing dgelsd" << std::endl; - if (test_over_gelsd(oss) == 0) - { - oss << "dgelsd passed." << std::endl; - } - oss << "End dgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing cgelsd" << std::endl; - if (test_over_gelsd(oss) == 0) - { - oss << "cgelsd passed." << std::endl; - } - oss << "End cgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing zgelsd" << std::endl; - if (test_over_gelsd(oss) == 0) - { - oss << "zgelsd passed." << std::endl; - } - oss << "End zgelsd tests" << std::endl; - oss << std::endl; - oss << "End Overdetermined Matrix Least Squares Test" << std::endl; -#endif - -#if TEST_MULTIPLE_SOLUTION_VECTORS - oss << std::endl; - oss << "Start Multiple Solution Vectors Least Squares Test" << std::endl; - oss << "Testing sgelsd" << std::endl; - if (test_multiple_gelsd(oss) == 0) - { - oss << "sgelsd passed." << std::endl; - } - oss << "End sgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing dgelsd" << std::endl; - if (test_multiple_gelsd(oss) == 0) - { - oss << "dgelsd passed." << std::endl; - } - oss << "End dgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing cgelsd" << std::endl; - if (test_multiple_gelsd(oss) == 0) - { - oss << "cgelsd passed." << std::endl; - } - oss << "End cgelsd tests" << std::endl; - oss << std::endl; - oss << "Testing zgelsd" << std::endl; - if (test_multiple_gelsd(oss) == 0) - { - oss << "zgelsd passed." << std::endl; - } - oss << "End zgelsd tests" << std::endl; - oss << std::endl; - oss << "End Multiple Solution Vectors Least Squares Test" << std::endl; -#endif - -#if OUTPUT_TO_FILE - // Finished testing - std::cout << std::endl; - std::cout << "Tests Completed." << std::endl; - std::cout << std::endl; - - std::string filename; - std::cout << "Enter filename to write test results: "; - std::getline(std::cin, filename); - - std::ofstream testFile(filename.c_str()); - - if (testFile) - { - testFile << oss.str(); - testFile.close(); - } -#else - std::cout << oss.str() << std::endl; - - // Finished testing - std::cout << std::endl; - std::cout << "Tests Completed." << std::endl; - std::cout << std::endl; -#endif - - // wait for user to finish - std::string done; - std::cout << "Press Enter to exit"; - std::getline(std::cin, done); - -} - -// tests square system (m-by-n where m == n) -template -int test_square_gelsd(StreamType& oss) -{ - // return value - int err = 0; - - // square matrix test - MatType mat(MatrixGenerator()(row_size, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests overdetermined system (m-by-n where m < n) -template -int test_under_gelsd(StreamType& oss) -{ - // return value - int err = 0; - - // under-determined matrix test - MatType mat(MatrixGenerator()(row_range, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests overdetermined system (m-by-n where m > n) -template -int test_over_gelsd(StreamType& oss) -{ - // return value - int err = 0; - - // overdetermined matrix test - MatType mat(MatrixGenerator()(row_size, col_range)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests multiple solution vectors stored column-wise in B for equation A*x=B -template -int test_multiple_gelsd(StreamType& oss) -{ - // return value - int err = 0; - - // multiple solutions vectors test - MatType mat(MatrixGenerator()(row_size, col_size)); - MatType vec(mat.size1(), 2); - ublas::column(vec, 0) = VectorGenerator()(mat.size1()); - ublas::column(vec, 1) = VectorGenerator()(mat.size1()); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - const int nrhs = traits::matrix_size2(vec); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - MatType optimalvec(vec); - err += lapack::gelsd(optimalmat, optimalvec, lapack::optimal_workspace()); - MatType optimalanswer(ublas::project(optimalvec, ublas::range(0, n), ublas::range(0, nrhs))); - MatType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - MatType minimalvec(vec); - err += lapack::gelsd(minimalmat, minimalvec, lapack::minimal_workspace()); - MatType minimalanswer(ublas::project(minimalvec, ublas::range(0, n), ublas::range(0, nrhs))); - MatType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - matrix_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - matrix_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - matrix_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - matrix_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - matrix_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./libs/numeric/bindings/lapack/test/ublas_gelss.cpp /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/ublas_gelss.cpp --- ./libs/numeric/bindings/lapack/test/ublas_gelss.cpp 2007-08-27 16:07:14.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/ublas_gelss.cpp 1969-12-31 19:00:00.000000000 -0500 @@ -1,435 +0,0 @@ - -#include "convenience.h" -#include - -// set to 1 for more output -//#define VERBOSE_OUTPUT 0 - -// set to 1 to write test output to file, otherwise outputs to console -#define OUTPUT_TO_FILE 0 - -// determines which tests to run -#define TEST_SQUARE 1 -#define TEST_UNDERDETERMINED 0 -#define TEST_OVERDETERMINED 0 -#define TEST_MULTIPLE_SOLUTION_VECTORS 0 - -// determines if optimal, minimal, or both workspaces are used for testing -#define USE_OPTIMAL_WORKSPACE 1 -#define USE_MINIMAL_WORKSPACE 0 - -namespace lapack = boost::numeric::bindings::lapack; - -// test function declarations -template -int test_square_gelss(StreamType& oss); - -template -int test_under_gelss(StreamType& oss); - -template -int test_over_gelss(StreamType& oss); - -template -int test_multiple_gelss(StreamType& oss); - -template -int test_transpose_gel(StreamType& oss, const char& trans); - - -int main() -{ - // stream for test output - typedef std::ostringstream stream_t; - stream_t oss; - -#if TEST_SQUARE - oss << "Start Square Matrix Least Squares Tests" << std::endl; - oss << "Testing sgelss" << std::endl; - if (test_square_gelss(oss) == 0) - { - oss << "sgelss passed." << std::endl; - } - oss << "End sgelss tests" << std::endl; - oss << std::endl; - oss << "Testing dgelss" << std::endl; - if (test_square_gelss(oss) == 0) - { - oss << "dgelss passed." << std::endl; - } - oss << "End dgelss tests" << std::endl; - oss << std::endl; - oss << "Testing cgelss" << std::endl; - if (test_square_gelss(oss) == 0) - { - oss << "cgelss passed." << std::endl; - } - oss << "End cgelss tests" << std::endl; - oss << std::endl; - oss << "Testing zgelss" << std::endl; - if (test_square_gelss(oss) == 0) - { - oss << "zgelss passed." << std::endl; - } - oss << "End zgelss tests" << std::endl; - oss << std::endl; - oss << "End Square Matrix Least Squares Tests" << std::endl; -#endif - -#if TEST_UNDERDETERMINED - oss << std::endl; - oss << "Start Under-determined Matrix Least Squares Test" << std::endl; - oss << "Testing sgelss" << std::endl; - if (test_under_gelss(oss) == 0) - { - oss << "sgelss passed." << std::endl; - } - oss << "End sgelss tests" << std::endl; - oss << std::endl; - oss << "Testing dgelss" << std::endl; - if (test_under_gelss(oss) == 0) - { - oss << "dgelss passed." << std::endl; - } - oss << "End dgelss tests" << std::endl; - oss << std::endl; - oss << "Testing cgelss" << std::endl; - if (test_under_gelss(oss) == 0) - { - oss << "cgelss passed." << std::endl; - } - oss << "End cgelss tests" << std::endl; - oss << std::endl; - oss << "Testing zgelss" << std::endl; - if (test_under_gelss(oss) == 0) - { - oss << "zgelss passed." << std::endl; - } - oss << "End zgelss tests" << std::endl; - oss << std::endl; - oss << "End Underdetermined Matrix Least Squares Tests" << std::endl; -#endif - -#if TEST_OVERDETERMINED - oss << std::endl; - oss << "Start Overdetermined Matrix Least Squares Test" << std::endl; - oss << "Testing sgelss" << std::endl; - if (test_over_gelss(oss) == 0) - { - oss << "sgelss passed." << std::endl; - } - oss << "End sgelss tests" << std::endl; - oss << std::endl; - oss << "Testing dgelss" << std::endl; - if (test_over_gelss(oss) == 0) - { - oss << "dgelss passed." << std::endl; - } - oss << "End dgelss tests" << std::endl; - oss << std::endl; - oss << "Testing cgelss" << std::endl; - if (test_over_gelss(oss) == 0) - { - oss << "cgelss passed." << std::endl; - } - oss << "End cgelss tests" << std::endl; - oss << std::endl; - oss << "Testing zgelss" << std::endl; - if (test_over_gelss(oss) == 0) - { - oss << "zgelss passed." << std::endl; - } - oss << "End zgelss tests" << std::endl; - oss << std::endl; - oss << "End Overdetermined Matrix Least Squares Test" << std::endl; -#endif - -#if TEST_MULTIPLE_SOLUTION_VECTORS - oss << std::endl; - oss << "Start Multiple Solution Vectors Least Squares Test" << std::endl; - oss << "Testing sgelss" << std::endl; - if (test_multiple_gelss(oss) == 0) - { - oss << "sgelss passed." << std::endl; - } - oss << "End sgelss tests" << std::endl; - oss << std::endl; - oss << "Testing dgelss" << std::endl; - if (test_multiple_gelss(oss) == 0) - { - oss << "dgelss passed." << std::endl; - } - oss << "End dgelss tests" << std::endl; - oss << std::endl; - oss << "Testing cgelss" << std::endl; - if (test_multiple_gelss(oss) == 0) - { - oss << "cgelss passed." << std::endl; - } - oss << "End cgelss tests" << std::endl; - oss << std::endl; - oss << "Testing zgelss" << std::endl; - if (test_multiple_gelss(oss) == 0) - { - oss << "zgelss passed." << std::endl; - } - oss << "End zgelss tests" << std::endl; - oss << std::endl; - oss << "End Multiple Solution Vectors Least Squares Test" << std::endl; -#endif - -#if OUTPUT_TO_FILE - // Finished testing - std::cout << std::endl; - std::cout << "Tests Completed." << std::endl; - std::cout << std::endl; - - std::string filename; - std::cout << "Enter filename to write test results: "; - std::getline(std::cin, filename); - - std::ofstream testFile(filename.c_str()); - - if (testFile) - { - testFile << oss.str(); - testFile.close(); - } -#else - std::cout << oss.str() << std::endl; - - // Finished testing - std::cout << std::endl; - std::cout << "Tests Completed." << std::endl; - std::cout << std::endl; -#endif - - // wait for user to finish - std::string done; - std::cout << "Press Enter to exit"; - std::getline(std::cin, done); - -} - -// tests square system (m-by-n where m == n) -template -int test_square_gelss(StreamType& oss) -{ - // return value - int err = 0; - - // square matrix test - MatType mat(MatrixGenerator()(row_size, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests overdetermined system (m-by-n where m < n) -template -int test_under_gelss(StreamType& oss) -{ - // return value - int err = 0; - - // under-determined matrix test - MatType mat(MatrixGenerator()(row_range, col_size)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests overdetermined system (m-by-n where m > n) -template -int test_over_gelss(StreamType& oss) -{ - // return value - int err = 0; - - // overdetermined matrix test - MatType mat(MatrixGenerator()(row_size, col_range)); - VecType vec(VectorGenerator()(row_size)); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - VecType optimalvec(vec); - err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); - VecType optimalanswer(ublas::project(optimalvec, ublas::range(0, n))); - VecType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - VecType minimalvec(vec); - err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); - VecType minimalanswer(ublas::project(minimalvec, ublas::range(0, n))); - VecType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - vector_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - vector_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - vector_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - vector_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} - -// tests multiple solution vectors stored column-wise in B for equation A*x=B -template -int test_multiple_gelss(StreamType& oss) -{ - // return value - int err = 0; - - // multiple solutions vectors test - MatType mat(MatrixGenerator()(row_size, col_size)); - MatType vec(mat.size1(), 2); - ublas::column(vec, 0) = VectorGenerator()(mat.size1()); - ublas::column(vec, 1) = VectorGenerator()(mat.size1()); - - const int m = traits::matrix_size1(mat); - const int n = traits::matrix_size2(mat); - const int nrhs = traits::matrix_size2(vec); - -#if USE_OPTIMAL_WORKSPACE - MatType optimalmat(mat); - MatType optimalvec(vec); - err += lapack::gelss(optimalmat, optimalvec, lapack::optimal_workspace()); - MatType optimalanswer(ublas::project(optimalvec, ublas::range(0, n), ublas::range(0, nrhs))); - MatType optimal_check = ublas::prod(mat, optimalanswer); -#endif -#if USE_MINIMAL_WORKSPACE - MatType minimalmat(mat); - MatType minimalvec(vec); - err += lapack::gelss(minimalmat, minimalvec, lapack::minimal_workspace()); - MatType minimalanswer(ublas::project(minimalvec, ublas::range(0, n), ublas::range(0, nrhs))); - MatType minimal_check = ublas::prod(mat, minimalanswer); -#endif - - matrix_print(oss, "A", mat); - oss << std::endl; - matrix_print(oss, "B", vec); - oss << std::endl; - -#if USE_OPTIMAL_WORKSPACE - matrix_print(oss, "optimal workspace x", optimalanswer); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - matrix_print(oss, "minimal workspace x", minimalanswer); - oss << std::endl; -#endif -#if USE_OPTIMAL_WORKSPACE - // check A*x=B - matrix_print(oss, "optimal A*x=B", optimal_check); - oss << std::endl; -#endif -#if USE_MINIMAL_WORKSPACE - matrix_print(oss, "minimal A*x=B", minimal_check); - oss << std::endl; -#endif - - return err; -} Binärdateien ./libs/numeric/bindings/lapack/test/unittest and /home/andreas/tmp/boost-sandbox/libs/numeric/bindings/lapack/test/unittest sind verschieden. diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./LICENSE_1_0.txt /home/andreas/tmp/boost-sandbox/LICENSE_1_0.txt --- ./LICENSE_1_0.txt 2004-03-15 13:59:25.000000000 -0500 +++ /home/andreas/tmp/boost-sandbox/LICENSE_1_0.txt 1969-12-31 19:00:00.000000000 -0500 @@ -1,23 +0,0 @@ -Boost Software License - Version 1.0 - August 17th, 2003 - -Permission is hereby granted, free of charge, to any person or organization -obtaining a copy of the software and accompanying documentation covered by -this license (the "Software") to use, reproduce, display, distribute, -execute, and transmit the Software, and to prepare derivative works of the -Software, and to permit third-parties to whom the Software is furnished to -do so, all subject to the following: - -The copyright notices in the Software and this entire statement, including -the above license grant, this restriction and the following disclaimer, -must be included in all copies of the Software, in whole or in part, and -all derivative works of the Software, unless such copies or derivative -works are solely in the form of machine-executable object code generated by -a source language processor. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT -SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE -FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, -ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./Makefile /home/andreas/tmp/boost-sandbox/Makefile --- ./Makefile 2008-04-12 19:25:30.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/Makefile 1969-12-31 19:00:00.000000000 -0500 @@ -1,8 +0,0 @@ -all: - true - -install: - for header in `find boost -name '*.hpp' -o -name '*.h'`; do \ - install -D $$header /home/andreas/pool/include/boost-bindings/$$header ; \ - done - diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./Makefile.in /home/andreas/tmp/boost-sandbox/Makefile.in --- ./Makefile.in 2007-11-07 19:38:27.000000000 -0500 +++ /home/andreas/tmp/boost-sandbox/Makefile.in 1969-12-31 19:00:00.000000000 -0500 @@ -1,8 +0,0 @@ -all: - true - -install: - for header in `find boost -name '*.hpp' -o -name '*.h'`; do \ - install -D $$header ${PREFIX}/include/boost-bindings/$$header ; \ - done - diff -x '*.rej' -x .svn -x .git -x '*.orig' -x '*.patch' -x '*~' -wruN ./README /home/andreas/tmp/boost-sandbox/README --- ./README 2008-06-10 12:56:15.000000000 -0400 +++ /home/andreas/tmp/boost-sandbox/README 1969-12-31 19:00:00.000000000 -0500 @@ -1,5 +0,0 @@ -How to obtain a new version: -svn co http://svn.boost.org/svn/boost/sandbox/boost/numeric/bindings - -Make a patch: -diff -x '.svn' -x '.git' -x "*.orig' -x '*.patch' -x '*~' -wruN . ~/tmp/boost-sandbox/