Subject: [Boost-commit] svn:boost r59014 - in sandbox/numeric_bindings: boost/numeric/bindings/lapack boost/numeric/bindings/lapack/computational boost/numeric/bindings/lapack/detail boost/numeric/bindings/lapack/driver libs/numeric/bindings/lapack/test libs/numeric/bindings/tools/templates/computational libs/numeric/bindings/tools/templates/driver
From: thomas.klimpel_at_[hidden]
Date: 2010-01-14 20:05:34
Author: klimpel
Date: 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
New Revision: 59014
URL: http://svn.boost.org/trac/boost/changeset/59014
Log:
regression tests ublas_hbevx, ublas_ptsv, ublas_steqr and ublas_sytrd pass now
Added:
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptcon.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrf.hpp (contents, props changed)
sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/pt.hpp (contents, props changed)
sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/steqr.hpp (contents, props changed)
sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pt.hpp (contents, props changed)
Removed:
sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ptsv.hpp
Text files modified:
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp | 2
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp | 160 ++++----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp | 414 +++++++++++------------
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp | 59 +-
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp | 172 +++++----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h | 22 +
sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h | 12
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp | 86 ++--
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 702 +++++++++++++++++++--------------------
sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_hbevx.cpp | 50 +-
sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_ptsv.cpp | 25 +
sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_steqr.cpp | 3
sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_sytrd.cpp | 14
13 files changed, 878 insertions(+), 843 deletions(-)
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -113,7 +113,9 @@
#include <boost/numeric/bindings/lapack/computational/pptrf.hpp>
#include <boost/numeric/bindings/lapack/computational/pptri.hpp>
#include <boost/numeric/bindings/lapack/computational/pptrs.hpp>
+#include <boost/numeric/bindings/lapack/computational/ptcon.hpp>
#include <boost/numeric/bindings/lapack/computational/ptrfs.hpp>
+#include <boost/numeric/bindings/lapack/computational/pttrf.hpp>
#include <boost/numeric/bindings/lapack/computational/pttrs.hpp>
#include <boost/numeric/bindings/lapack/computational/spcon.hpp>
#include <boost/numeric/bindings/lapack/computational/sprfs.hpp>
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptcon.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptcon.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,296 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTCON_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTCON_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for ptcon is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t ptcon( const fortran_int_t n, const float* d,
+ const float* e, const float anorm, float& rcond, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SPTCON( &n, d, e, &anorm, &rcond, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t ptcon( const fortran_int_t n, const double* d,
+ const double* e, const double anorm, double& rcond, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DPTCON( &n, d, e, &anorm, &rcond, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t ptcon( const fortran_int_t n, const float* d,
+ const std::complex<float>* e, const float anorm, float& rcond,
+ float* rwork ) {
+ fortran_int_t info(0);
+ LAPACK_CPTCON( &n, d, e, &anorm, &rcond, rwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t ptcon( const fortran_int_t n, const double* d,
+ const std::complex<double>* e, const double anorm, double& rcond,
+ double* rwork ) {
+ fortran_int_t info(0);
+ LAPACK_ZPTCON( &n, d, e, &anorm, &rcond, rwork, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to ptcon.
+//
+template< typename Value, typename Enable = void >
+struct ptcon_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct ptcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorD, typename VectorE, typename WORK >
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const real_type anorm, real_type& rcond, detail::workspace1<
+ WORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorE >::type >::type >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_work( bindings::size(d) ));
+ return detail::ptcon( bindings::size(d), bindings::begin_value(d),
+ bindings::begin_value(e), anorm, rcond,
+ bindings::begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorD, typename VectorE >
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ return invoke( d, e, anorm, rcond, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorD, typename VectorE >
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ return invoke( d, e, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct ptcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorD, typename VectorE, typename RWORK >
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const real_type anorm, real_type& rcond, detail::workspace1<
+ RWORK > work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
+ BOOST_ASSERT( bindings::size(work.select(real_type())) >=
+ min_size_rwork( bindings::size(d) ));
+ return detail::ptcon( bindings::size(d), bindings::begin_value(d),
+ bindings::begin_value(e), anorm, rcond,
+ bindings::begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename VectorD, typename VectorE >
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ bindings::size(d) ) );
+ return invoke( d, e, anorm, rcond, workspace( tmp_rwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename VectorD, typename VectorE >
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ namespace bindings = ::boost::numeric::bindings;
+ return invoke( d, e, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array rwork.
+ //
+ static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the ptcon_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for ptcon. Its overload differs for
+// * User-defined workspace
+//
+template< typename VectorD, typename VectorE, typename Workspace >
+inline typename boost::enable_if< detail::is_workspace< Workspace >,
+ std::ptrdiff_t >::type
+ptcon( const VectorD& d, const VectorE& e,
+ const typename remove_imaginary< typename value<
+ VectorE >::type >::type anorm, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond, Workspace work ) {
+ return ptcon_impl< typename value< VectorE >::type >::invoke( d, e,
+ anorm, rcond, work );
+}
+
+//
+// Overloaded function for ptcon. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename VectorD, typename VectorE >
+inline typename boost::disable_if< detail::is_workspace< VectorE >,
+ std::ptrdiff_t >::type
+ptcon( const VectorD& d, const VectorE& e,
+ const typename remove_imaginary< typename value<
+ VectorE >::type >::type anorm, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond ) {
+ return ptcon_impl< typename value< VectorE >::type >::invoke( d, e,
+ anorm, rcond, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -124,9 +124,8 @@
//
template< typename VectorD, typename VectorE, typename MatrixZ,
typename WORK >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1<
- WORK > work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, detail::workspace1< WORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -139,17 +138,17 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( n ));
+ min_size_work( bindings::size(d) ));
BOOST_ASSERT( bindings::size_minor(z) == 1 ||
bindings::stride_minor(z) == 1 );
BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
- BOOST_ASSERT( n >= 0 );
- return detail::pteqr( compz, n, bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(z),
- bindings::stride_major(z),
+ return detail::pteqr( compz, bindings::size(d),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(z), bindings::stride_major(z),
bindings::begin_value(work.select(real_type())) );
}
@@ -161,11 +160,12 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( compz, n, d, e, z, workspace( tmp_work ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ return invoke( compz, d, e, z, workspace( tmp_work ) );
}
//
@@ -176,10 +176,10 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( compz, n, d, e, z, minimal_workspace() );
+ return invoke( compz, d, e, z, minimal_workspace() );
}
//
@@ -208,9 +208,8 @@
//
template< typename VectorD, typename VectorE, typename MatrixZ,
typename WORK >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1<
- WORK > work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, detail::workspace1< WORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -219,17 +218,17 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( n ));
+ min_size_work( bindings::size(d) ));
BOOST_ASSERT( bindings::size_minor(z) == 1 ||
bindings::stride_minor(z) == 1 );
BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
- BOOST_ASSERT( n >= 0 );
- return detail::pteqr( compz, n, bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(z),
- bindings::stride_major(z),
+ return detail::pteqr( compz, bindings::size(d),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(z), bindings::stride_major(z),
bindings::begin_value(work.select(real_type())) );
}
@@ -241,11 +240,12 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( compz, n, d, e, z, workspace( tmp_work ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ return invoke( compz, d, e, z, workspace( tmp_work ) );
}
//
@@ -256,10 +256,10 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( compz, n, d, e, z, minimal_workspace() );
+ return invoke( compz, d, e, z, minimal_workspace() );
}
//
@@ -292,10 +292,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work ) {
+pteqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -308,10 +308,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixZ& z ) {
+pteqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -325,10 +324,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work ) {
+pteqr( const char compz, const VectorD& d, VectorE& e, MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -341,10 +340,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, MatrixZ& z ) {
+pteqr( const char compz, const VectorD& d, VectorE& e, MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -358,10 +356,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, MatrixZ& z, Workspace work ) {
+pteqr( const char compz, VectorD& d, const VectorE& e, MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -374,10 +372,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, MatrixZ& z ) {
+pteqr( const char compz, VectorD& d, const VectorE& e, MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -391,10 +388,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixZ& z, Workspace work ) {
+pteqr( const char compz, const VectorD& d, const VectorE& e, MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -407,10 +404,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixZ& z ) {
+pteqr( const char compz, const VectorD& d, const VectorE& e,
+ MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -424,10 +421,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, const MatrixZ& z, Workspace work ) {
+pteqr( const char compz, VectorD& d, VectorE& e, const MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -440,10 +437,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, const MatrixZ& z ) {
+pteqr( const char compz, VectorD& d, VectorE& e, const MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -457,10 +453,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, const MatrixZ& z, Workspace work ) {
+pteqr( const char compz, const VectorD& d, VectorE& e, const MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -473,10 +469,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, const MatrixZ& z ) {
+pteqr( const char compz, const VectorD& d, VectorE& e,
+ const MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -490,10 +486,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, const MatrixZ& z, Workspace work ) {
+pteqr( const char compz, VectorD& d, const VectorE& e, const MatrixZ& z,
+ Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -506,10 +502,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, const MatrixZ& z ) {
+pteqr( const char compz, VectorD& d, const VectorE& e,
+ const MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -523,10 +519,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const MatrixZ& z, Workspace work ) {
+pteqr( const char compz, const VectorD& d, const VectorE& e,
+ const MatrixZ& z, Workspace work ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -539,10 +535,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-pteqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const MatrixZ& z ) {
+pteqr( const char compz, const VectorD& d, const VectorE& e,
+ const MatrixZ& z ) {
return pteqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -141,9 +141,9 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK >
- static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
detail::workspace1< WORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -178,23 +178,23 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(df) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
- BOOST_ASSERT( bindings::size(ef) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(df) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
+ BOOST_ASSERT( bindings::size(ef) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( n ));
+ min_size_work( bindings::size(d) ));
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::size_minor(x) == 1 ||
bindings::stride_minor(x) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
+ bindings::size(d)) );
BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::ptrfs( n, bindings::size_column(b),
+ bindings::size(d)) );
+ return detail::ptrfs( bindings::size(d), bindings::size_column(b),
bindings::begin_value(d), bindings::begin_value(e),
bindings::begin_value(df), bindings::begin_value(ef),
bindings::begin_value(b), bindings::stride_major(b),
@@ -213,14 +213,14 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( n, d, e, df, ef, b, x, ferr, berr,
- workspace( tmp_work ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ return invoke( d, e, df, ef, b, x, ferr, berr, workspace( tmp_work ) );
}
//
@@ -233,13 +233,12 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( n, d, e, df, ef, b, x, ferr, berr,
- minimal_workspace() );
+ return invoke( d, e, df, ef, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -270,11 +269,10 @@
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename RWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const VectorD& d, const VectorE& e, const VectorDF& df,
- const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
- RWORK > work ) {
+ static std::ptrdiff_t invoke( const char uplo, const VectorD& d,
+ const VectorE& e, const VectorDF& df, const VectorEF& ef,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, RWORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -304,30 +302,31 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(df) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
- BOOST_ASSERT( bindings::size(ef) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(df) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
+ BOOST_ASSERT( bindings::size(ef) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_rwork( n ));
+ min_size_rwork( bindings::size(d) ));
BOOST_ASSERT( bindings::size(work.select(value_type())) >=
- min_size_work( n ));
+ min_size_work( bindings::size(d) ));
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::size_minor(x) == 1 ||
bindings::stride_minor(x) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
+ bindings::size(d)) );
BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::ptrfs( uplo, n, bindings::size_column(b),
- bindings::begin_value(d), bindings::begin_value(e),
- bindings::begin_value(df), bindings::begin_value(ef),
- bindings::begin_value(b), bindings::stride_major(b),
- bindings::begin_value(x), bindings::stride_major(x),
- bindings::begin_value(ferr), bindings::begin_value(berr),
+ bindings::size(d)) );
+ return detail::ptrfs( uplo, bindings::size(d),
+ bindings::size_column(b), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(df),
+ bindings::begin_value(ef), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), bindings::begin_value(ferr),
+ bindings::begin_value(berr),
bindings::begin_value(work.select(value_type())),
bindings::begin_value(work.select(real_type())) );
}
@@ -342,14 +341,16 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const VectorD& d, const VectorE& e, const VectorDF& df,
- const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char uplo, const VectorD& d,
+ const VectorE& e, const VectorDF& df, const VectorEF& ef,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( uplo, n, d, e, df, ef, b, x, ferr, berr,
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ bindings::size(d) ) );
+ return invoke( uplo, d, e, df, ef, b, x, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -363,12 +364,12 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const VectorD& d, const VectorE& e, const VectorDF& df,
- const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char uplo, const VectorD& d,
+ const VectorE& e, const VectorDF& df, const VectorEF& ef,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( uplo, n, d, e, df, ef, b, x, ferr, berr,
+ return invoke( uplo, d, e, df, ef, b, x, ferr, berr,
minimal_workspace() );
}
@@ -411,11 +412,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -430,11 +431,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -449,12 +450,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -469,11 +469,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -488,11 +488,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -507,11 +507,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
const VectorFERR& ferr, VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -526,12 +526,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -546,11 +545,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -565,11 +564,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -584,11 +583,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
- VectorFERR& ferr, const VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -603,12 +602,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -623,11 +621,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -642,11 +640,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -661,11 +659,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
const VectorFERR& ferr, const VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -680,12 +678,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, work );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, work );
}
//
@@ -700,11 +697,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const fortran_int_t n, const VectorD& d, const VectorE& e,
- const VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
- return ptrfs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return ptrfs_impl< typename value< VectorE >::type >::invoke( d, e,
+ df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
// Overloaded function for ptrfs. Its overload differs for
@@ -718,12 +715,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -738,11 +734,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -757,12 +753,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -777,12 +773,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -797,12 +792,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -817,12 +811,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -837,12 +830,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -857,12 +850,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -877,12 +869,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -897,12 +888,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -917,12 +907,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
+ Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -937,12 +927,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -957,12 +946,11 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -977,12 +965,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -997,12 +984,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
+ Workspace work ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, work );
+ d, e, df, ef, b, x, ferr, berr, work );
}
//
@@ -1017,12 +1004,11 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptrfs( const char uplo, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
+ptrfs( const char uplo, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
return ptrfs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, ferr, berr, optimal_workspace() );
}
} // namespace lapack
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrf.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrf.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,220 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// 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)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRF_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRF_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for pttrf is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t pttrf( const fortran_int_t n, float* d, float* e ) {
+ fortran_int_t info(0);
+ LAPACK_SPTTRF( &n, d, e, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t pttrf( const fortran_int_t n, double* d, double* e ) {
+ fortran_int_t info(0);
+ LAPACK_DPTTRF( &n, d, e, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t pttrf( const fortran_int_t n, float* d,
+ std::complex<float>* e ) {
+ fortran_int_t info(0);
+ LAPACK_CPTTRF( &n, d, e, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t pttrf( const fortran_int_t n, double* d,
+ std::complex<double>* e ) {
+ fortran_int_t info(0);
+ LAPACK_ZPTTRF( &n, d, e, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to pttrf.
+//
+template< typename Value, typename Enable = void >
+struct pttrf_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct pttrf_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorD, typename VectorE >
+ static std::ptrdiff_t invoke( VectorD& d, VectorE& e ) {
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorE >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
+ return detail::pttrf( bindings::size(d), bindings::begin_value(d),
+ bindings::begin_value(e) );
+ }
+
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct pttrf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename VectorD, typename VectorE >
+ static std::ptrdiff_t invoke( VectorD& d, VectorE& e ) {
+ namespace bindings = ::boost::numeric::bindings;
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
+ return detail::pttrf( bindings::size(d), bindings::begin_value(d),
+ bindings::begin_value(e) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the pttrf_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for pttrf. Its overload differs for
+// * VectorD&
+// * VectorE&
+//
+template< typename VectorD, typename VectorE >
+inline std::ptrdiff_t pttrf( VectorD& d, VectorE& e ) {
+ return pttrf_impl< typename value< VectorE >::type >::invoke( d, e );
+}
+
+//
+// Overloaded function for pttrf. Its overload differs for
+// * const VectorD&
+// * VectorE&
+//
+template< typename VectorD, typename VectorE >
+inline std::ptrdiff_t pttrf( const VectorD& d, VectorE& e ) {
+ return pttrf_impl< typename value< VectorE >::type >::invoke( d, e );
+}
+
+//
+// Overloaded function for pttrf. Its overload differs for
+// * VectorD&
+// * const VectorE&
+//
+template< typename VectorD, typename VectorE >
+inline std::ptrdiff_t pttrf( VectorD& d, const VectorE& e ) {
+ return pttrf_impl< typename value< VectorE >::type >::invoke( d, e );
+}
+
+//
+// Overloaded function for pttrf. Its overload differs for
+// * const VectorD&
+// * const VectorE&
+//
+template< typename VectorD, typename VectorE >
+inline std::ptrdiff_t pttrf( const VectorD& d, const VectorE& e ) {
+ return pttrf_impl< typename value< VectorE >::type >::invoke( d, e );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pttrs.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -124,8 +124,8 @@
// * Asserts that most arguments make sense.
//
template< typename VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
+ MatrixB& b ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -136,15 +136,15 @@
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::pttrs( n, bindings::size_column(b),
+ bindings::size(d)) );
+ return detail::pttrs( bindings::size(d), bindings::size_column(b),
bindings::begin_value(d), bindings::begin_value(e),
bindings::begin_value(b), bindings::stride_major(b) );
}
@@ -167,24 +167,25 @@
// * Asserts that most arguments make sense.
//
template< typename VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const VectorD& d, const VectorE& e, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const char uplo, const VectorD& d,
+ const VectorE& e, MatrixB& b ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorE >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::pttrs( uplo, n, bindings::size_column(b),
- bindings::begin_value(d), bindings::begin_value(e),
- bindings::begin_value(b), bindings::stride_major(b) );
+ bindings::size(d)) );
+ return detail::pttrs( uplo, bindings::size(d),
+ bindings::size_column(b), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(b),
+ bindings::stride_major(b) );
}
};
@@ -204,10 +205,10 @@
// * MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t pttrs( const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixB& b ) {
- return pttrs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t pttrs( const VectorD& d, const VectorE& e,
+ MatrixB& b ) {
+ return pttrs_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -215,20 +216,20 @@
// * const MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t pttrs( const fortran_int_t n, const VectorD& d,
- const VectorE& e, const MatrixB& b ) {
- return pttrs_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t pttrs( const VectorD& d, const VectorE& e,
+ const MatrixB& b ) {
+ return pttrs_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
// Overloaded function for pttrs. Its overload differs for
// * MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t pttrs( const char uplo, const fortran_int_t n,
- const VectorD& d, const VectorE& e, MatrixB& b ) {
+inline std::ptrdiff_t pttrs( const char uplo, const VectorD& d,
+ const VectorE& e, MatrixB& b ) {
return pttrs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, b );
+ d, e, b );
}
//
@@ -236,10 +237,10 @@
// * const MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t pttrs( const char uplo, const fortran_int_t n,
- const VectorD& d, const VectorE& e, const MatrixB& b ) {
+inline std::ptrdiff_t pttrs( const char uplo, const VectorD& d,
+ const VectorE& e, const MatrixB& b ) {
return pttrs_impl< typename value< VectorE >::type >::invoke( uplo,
- n, d, e, b );
+ d, e, b );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -124,9 +124,8 @@
//
template< typename VectorD, typename VectorE, typename MatrixZ,
typename WORK >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1<
- WORK > work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, detail::workspace1< WORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -139,16 +138,16 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( $CALL_MIN_SIZE ));
+ min_size_work( bindings::size(d), compz ));
BOOST_ASSERT( bindings::size_minor(z) == 1 ||
bindings::stride_minor(z) == 1 );
BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
- BOOST_ASSERT( n >= 0 );
- return detail::steqr( compz, n, bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(z),
- bindings::stride_major(z),
+ return detail::steqr( compz, bindings::size(d),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(z), bindings::stride_major(z),
bindings::begin_value(work.select(real_type())) );
}
@@ -160,12 +159,12 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- $CALL_MIN_SIZE ) );
- return invoke( compz, n, d, e, z, workspace( tmp_work ) );
+ bindings::size(d), compz ) );
+ return invoke( compz, d, e, z, workspace( tmp_work ) );
}
//
@@ -176,18 +175,23 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( compz, n, d, e, z, minimal_workspace() );
+ return invoke( compz, d, e, z, minimal_workspace() );
}
//
// Static member function that returns the minimum size of
// workspace-array work.
//
- static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
- $MIN_SIZE
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n,
+ const char compz ) {
+ if ( compz == 'N' ) {
+ return 1;
+ } else {
+ return std::max< std::ptrdiff_t >( 1, 2*n-2 );
+ }
}
};
@@ -208,9 +212,8 @@
//
template< typename VectorD, typename VectorE, typename MatrixZ,
typename WORK >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1<
- WORK > work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, detail::workspace1< WORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -219,16 +222,16 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( $CALL_MIN_SIZE ));
+ min_size_work( bindings::size(d), compz ));
BOOST_ASSERT( bindings::size_minor(z) == 1 ||
bindings::stride_minor(z) == 1 );
BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' );
- BOOST_ASSERT( n >= 0 );
- return detail::steqr( compz, n, bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(z),
- bindings::stride_major(z),
+ return detail::steqr( compz, bindings::size(d),
+ bindings::begin_value(d), bindings::begin_value(e),
+ bindings::begin_value(z), bindings::stride_major(z),
bindings::begin_value(work.select(real_type())) );
}
@@ -240,12 +243,12 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< real_type > tmp_work( min_size_work(
- $CALL_MIN_SIZE ) );
- return invoke( compz, n, d, e, z, workspace( tmp_work ) );
+ bindings::size(d), compz ) );
+ return invoke( compz, d, e, z, workspace( tmp_work ) );
}
//
@@ -256,18 +259,23 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename VectorD, typename VectorE, typename MatrixZ >
- static std::ptrdiff_t invoke( const char compz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e,
+ MatrixZ& z, optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( compz, n, d, e, z, minimal_workspace() );
+ return invoke( compz, d, e, z, minimal_workspace() );
}
//
// Static member function that returns the minimum size of
// workspace-array work.
//
- static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
- $MIN_SIZE
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n,
+ const char compz ) {
+ if ( compz == 'N' ) {
+ return 1;
+ } else {
+ return std::max< std::ptrdiff_t >( 1, 2*n-2 );
+ }
}
};
@@ -292,10 +300,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work ) {
+steqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -308,10 +316,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixZ& z ) {
+steqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -325,10 +332,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, MatrixZ& z, Workspace work ) {
+steqr( const char compz, const VectorD& d, VectorE& e, MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -341,10 +348,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, MatrixZ& z ) {
+steqr( const char compz, const VectorD& d, VectorE& e, MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -358,10 +364,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, MatrixZ& z, Workspace work ) {
+steqr( const char compz, VectorD& d, const VectorE& e, MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -374,10 +380,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, MatrixZ& z ) {
+steqr( const char compz, VectorD& d, const VectorE& e, MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -391,10 +396,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixZ& z, Workspace work ) {
+steqr( const char compz, const VectorD& d, const VectorE& e, MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -407,10 +412,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixZ& z ) {
+steqr( const char compz, const VectorD& d, const VectorE& e,
+ MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -424,10 +429,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, const MatrixZ& z, Workspace work ) {
+steqr( const char compz, VectorD& d, VectorE& e, const MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -440,10 +445,9 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- VectorE& e, const MatrixZ& z ) {
+steqr( const char compz, VectorD& d, VectorE& e, const MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -457,10 +461,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, const MatrixZ& z, Workspace work ) {
+steqr( const char compz, const VectorD& d, VectorE& e, const MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -473,10 +477,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- VectorE& e, const MatrixZ& z ) {
+steqr( const char compz, const VectorD& d, VectorE& e,
+ const MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -490,10 +494,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, const MatrixZ& z, Workspace work ) {
+steqr( const char compz, VectorD& d, const VectorE& e, const MatrixZ& z,
+ Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -506,10 +510,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, VectorD& d,
- const VectorE& e, const MatrixZ& z ) {
+steqr( const char compz, VectorD& d, const VectorE& e,
+ const MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
//
@@ -523,10 +527,10 @@
typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const MatrixZ& z, Workspace work ) {
+steqr( const char compz, const VectorD& d, const VectorE& e,
+ const MatrixZ& z, Workspace work ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, work );
+ d, e, z, work );
}
//
@@ -539,10 +543,10 @@
template< typename VectorD, typename VectorE, typename MatrixZ >
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
std::ptrdiff_t >::type
-steqr( const char compz, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const MatrixZ& z ) {
+steqr( const char compz, const VectorD& d, const VectorE& e,
+ const MatrixZ& z ) {
return steqr_impl< typename value< MatrixZ >::type >::invoke( compz,
- n, d, e, z, optimal_workspace() );
+ d, e, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -1470,6 +1470,18 @@
const fortran_int_t* nrhs, const void* ap, void* b,
const fortran_int_t* ldb, fortran_int_t* info );
+// Value-type variants of ptcon
+void LAPACK_SPTCON( const fortran_int_t* n, const float* d, const float* e,
+ const float* anorm, float* rcond, float* work, fortran_int_t* info );
+void LAPACK_DPTCON( const fortran_int_t* n, const double* d, const double* e,
+ const double* anorm, double* rcond, double* work,
+ fortran_int_t* info );
+void LAPACK_CPTCON( const fortran_int_t* n, const float* d, const void* e,
+ const float* anorm, float* rcond, float* rwork, fortran_int_t* info );
+void LAPACK_ZPTCON( const fortran_int_t* n, const double* d, const void* e,
+ const double* anorm, double* rcond, double* rwork,
+ fortran_int_t* info );
+
// Value-type variants of ptrfs
void LAPACK_SPTRFS( const fortran_int_t* n, const fortran_int_t* nrhs,
const float* d, const float* e, const float* df, const float* ef,
@@ -1494,6 +1506,16 @@
double* ferr, double* berr, void* work, double* rwork,
fortran_int_t* info );
+// Value-type variants of pttrf
+void LAPACK_SPTTRF( const fortran_int_t* n, float* d, float* e,
+ fortran_int_t* info );
+void LAPACK_DPTTRF( const fortran_int_t* n, double* d, double* e,
+ fortran_int_t* info );
+void LAPACK_CPTTRF( const fortran_int_t* n, float* d, void* e,
+ fortran_int_t* info );
+void LAPACK_ZPTTRF( const fortran_int_t* n, double* d, void* e,
+ fortran_int_t* info );
+
// Value-type variants of pttrs
void LAPACK_SPTTRS( const fortran_int_t* n, const fortran_int_t* nrhs,
const float* d, const float* e, float* b, const fortran_int_t* ldb,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -534,12 +534,24 @@
#define LAPACK_CPPTRS FORTRAN_ID( cpptrs )
#define LAPACK_ZPPTRS FORTRAN_ID( zpptrs )
+// Value-type variants of ptcon
+#define LAPACK_SPTCON FORTRAN_ID( sptcon )
+#define LAPACK_DPTCON FORTRAN_ID( dptcon )
+#define LAPACK_CPTCON FORTRAN_ID( cptcon )
+#define LAPACK_ZPTCON FORTRAN_ID( zptcon )
+
// Value-type variants of ptrfs
#define LAPACK_SPTRFS FORTRAN_ID( sptrfs )
#define LAPACK_DPTRFS FORTRAN_ID( dptrfs )
#define LAPACK_CPTRFS FORTRAN_ID( cptrfs )
#define LAPACK_ZPTRFS FORTRAN_ID( zptrfs )
+// Value-type variants of pttrf
+#define LAPACK_SPTTRF FORTRAN_ID( spttrf )
+#define LAPACK_DPTTRF FORTRAN_ID( dpttrf )
+#define LAPACK_CPTTRF FORTRAN_ID( cpttrf )
+#define LAPACK_ZPTTRF FORTRAN_ID( zpttrf )
+
// Value-type variants of pttrs
#define LAPACK_SPTTRS FORTRAN_ID( spttrs )
#define LAPACK_DPTTRS FORTRAN_ID( dpttrs )
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsv.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -120,8 +120,7 @@
// * Asserts that most arguments make sense.
//
template< typename VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixB& b ) {
+ static std::ptrdiff_t invoke( VectorD& d, VectorE& e, MatrixB& b ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -134,15 +133,15 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::ptsv( n, bindings::size_column(b),
+ bindings::size(d)) );
+ return detail::ptsv( bindings::size(d), bindings::size_column(b),
bindings::begin_value(d), bindings::begin_value(e),
bindings::begin_value(b), bindings::stride_major(b) );
}
@@ -165,8 +164,7 @@
// * Asserts that most arguments make sense.
//
template< typename VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixB& b ) {
+ static std::ptrdiff_t invoke( VectorD& d, VectorE& e, MatrixB& b ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorE >::type >::type,
@@ -175,15 +173,15 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::ptsv( n, bindings::size_column(b),
+ bindings::size(d)) );
+ return detail::ptsv( bindings::size(d), bindings::size_column(b),
bindings::begin_value(d), bindings::begin_value(e),
bindings::begin_value(b), bindings::stride_major(b) );
}
@@ -207,10 +205,9 @@
// * MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, VectorD& d,
- VectorE& e, MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( VectorD& d, VectorE& e, MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -220,10 +217,9 @@
// * MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, const VectorD& d,
- VectorE& e, MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( const VectorD& d, VectorE& e, MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -233,10 +229,9 @@
// * MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, VectorD& d,
- const VectorE& e, MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( VectorD& d, const VectorE& e, MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -246,10 +241,10 @@
// * MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, const VectorD& d,
- const VectorE& e, MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( const VectorD& d, const VectorE& e,
+ MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -259,10 +254,9 @@
// * const MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, VectorD& d,
- VectorE& e, const MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( VectorD& d, VectorE& e, const MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -272,10 +266,10 @@
// * const MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, const VectorD& d,
- VectorE& e, const MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( const VectorD& d, VectorE& e,
+ const MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -285,10 +279,10 @@
// * const MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, VectorD& d,
- const VectorE& e, const MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( VectorD& d, const VectorE& e,
+ const MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
//
@@ -298,10 +292,10 @@
// * const MatrixB&
//
template< typename VectorD, typename VectorE, typename MatrixB >
-inline std::ptrdiff_t ptsv( const fortran_int_t n, const VectorD& d,
- const VectorE& e, const MatrixB& b ) {
- return ptsv_impl< typename value< VectorE >::type >::invoke( n, d,
- e, b );
+inline std::ptrdiff_t ptsv( const VectorD& d, const VectorE& e,
+ const MatrixB& b ) {
+ return ptsv_impl< typename value< VectorE >::type >::invoke( d, e,
+ b );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -141,10 +141,10 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char fact, const VectorD& d,
+ const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
+ MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace1< WORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -180,27 +180,28 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( n ));
+ min_size_work( bindings::size(d) ));
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::size_minor(x) == 1 ||
bindings::stride_minor(x) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
+ bindings::size(d)) );
BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
- n) );
+ bindings::size(d)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- BOOST_ASSERT( n >= 0 );
- return detail::ptsvx( fact, n, bindings::size_column(b),
- bindings::begin_value(d), bindings::begin_value(e),
- bindings::begin_value(df), bindings::begin_value(ef),
- bindings::begin_value(b), bindings::stride_major(b),
- bindings::begin_value(x), bindings::stride_major(x), rcond,
- bindings::begin_value(ferr), bindings::begin_value(berr),
+ return detail::ptsvx( fact, bindings::size(d),
+ bindings::size_column(b), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(df),
+ bindings::begin_value(ef), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), rcond, bindings::begin_value(ferr),
+ bindings::begin_value(berr),
bindings::begin_value(work.select(real_type())) );
}
@@ -214,13 +215,14 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char fact, const VectorD& d,
+ const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
+ MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr,
workspace( tmp_work ) );
}
@@ -234,12 +236,12 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char fact, const VectorD& d,
+ const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
+ MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
+ return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr,
minimal_workspace() );
}
@@ -271,10 +273,10 @@
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename RWORK >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char fact, const VectorD& d,
+ const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
+ MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, RWORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
@@ -306,29 +308,30 @@
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
+ BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
+ BOOST_ASSERT( bindings::size(d) >= 0 );
+ BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_rwork( n ));
+ min_size_rwork( bindings::size(d) ));
BOOST_ASSERT( bindings::size(work.select(value_type())) >=
- min_size_work( n ));
+ min_size_work( bindings::size(d) ));
BOOST_ASSERT( bindings::size_column(b) >= 0 );
BOOST_ASSERT( bindings::size_minor(b) == 1 ||
bindings::stride_minor(b) == 1 );
BOOST_ASSERT( bindings::size_minor(x) == 1 ||
bindings::stride_minor(x) == 1 );
BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
+ bindings::size(d)) );
BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
- n) );
+ bindings::size(d)) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- BOOST_ASSERT( n >= 0 );
- return detail::ptsvx( fact, n, bindings::size_column(b),
- bindings::begin_value(d), bindings::begin_value(e),
- bindings::begin_value(df), bindings::begin_value(ef),
- bindings::begin_value(b), bindings::stride_major(b),
- bindings::begin_value(x), bindings::stride_major(x), rcond,
- bindings::begin_value(ferr), bindings::begin_value(berr),
+ return detail::ptsvx( fact, bindings::size(d),
+ bindings::size_column(b), bindings::begin_value(d),
+ bindings::begin_value(e), bindings::begin_value(df),
+ bindings::begin_value(ef), bindings::begin_value(b),
+ bindings::stride_major(b), bindings::begin_value(x),
+ bindings::stride_major(x), rcond, bindings::begin_value(ferr),
+ bindings::begin_value(berr),
bindings::begin_value(work.select(value_type())),
bindings::begin_value(work.select(real_type())) );
}
@@ -343,14 +346,16 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char fact, const VectorD& d,
+ const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
+ MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ bindings::size(d) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ bindings::size(d) ) );
+ return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -364,12 +369,12 @@
template< typename VectorD, typename VectorE, typename VectorDF,
typename VectorEF, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const VectorD& d, const VectorE& e, VectorDF& df, VectorEF& ef,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char fact, const VectorD& d,
+ const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
+ MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
namespace bindings = ::boost::numeric::bindings;
- return invoke( fact, n, d, e, df, ef, b, x, rcond, ferr, berr,
+ return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr,
minimal_workspace() );
}
@@ -414,13 +419,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -437,12 +441,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
+ VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -459,13 +463,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -482,12 +486,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -504,13 +508,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -527,12 +531,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -549,13 +553,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -572,13 +576,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -595,13 +598,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -618,12 +621,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -640,13 +643,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -663,12 +666,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -685,13 +688,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -708,12 +711,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -730,13 +733,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -753,13 +756,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -776,13 +778,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -799,13 +800,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, const VectorFERR& ferr,
- VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond,
+ const VectorFERR& ferr, VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -822,13 +822,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -845,13 +845,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -868,13 +868,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -891,13 +891,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -914,13 +914,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -937,13 +937,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -960,13 +960,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -983,13 +983,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1006,13 +1006,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1029,13 +1029,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1052,13 +1052,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1075,13 +1075,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1098,13 +1098,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1121,13 +1121,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1144,13 +1144,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, VectorFERR& ferr,
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1167,13 +1166,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, VectorFERR& ferr,
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1190,13 +1188,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1213,13 +1211,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1236,13 +1234,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1259,13 +1257,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1282,13 +1280,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1305,13 +1303,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1328,13 +1326,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1351,13 +1349,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1374,13 +1372,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1397,13 +1395,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1420,13 +1418,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1443,13 +1441,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1466,13 +1464,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1489,13 +1487,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond, VectorFERR& ferr,
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1512,13 +1510,12 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1535,13 +1532,12 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
- VectorE >::type >::type& rcond, const VectorFERR& ferr,
- const VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary<
+ typename value< VectorE >::type >::type& rcond,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1558,13 +1554,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1581,13 +1577,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1604,13 +1600,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1627,13 +1623,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1650,13 +1646,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1673,13 +1669,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1696,13 +1692,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1719,13 +1715,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1742,13 +1738,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1765,13 +1761,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1788,13 +1784,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1811,13 +1807,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, VectorDF& df, const VectorEF& ef, const MatrixB& b,
- const MatrixX& x, typename remove_imaginary< typename value<
+ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df,
+ const VectorEF& ef, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
VectorE >::type >::type& rcond, const VectorFERR& ferr,
const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1834,13 +1830,13 @@
typename VectorFERR, typename VectorBERR, typename Workspace >
inline typename boost::enable_if< detail::is_workspace< Workspace >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, work );
+ d, e, df, ef, b, x, rcond, ferr, berr, work );
}
//
@@ -1857,13 +1853,13 @@
typename VectorFERR, typename VectorBERR >
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
std::ptrdiff_t >::type
-ptsvx( const char fact, const fortran_int_t n, const VectorD& d,
- const VectorE& e, const VectorDF& df, const VectorEF& ef,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< VectorE >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+ptsvx( const char fact, const VectorD& d, const VectorE& e,
+ const VectorDF& df, const VectorEF& ef, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ VectorE >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return ptsvx_impl< typename value< VectorE >::type >::invoke( fact,
- n, d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
+ d, e, df, ef, b, x, rcond, ferr, berr, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_hbevx.cpp
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_hbevx.cpp (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_hbevx.cpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -11,8 +11,8 @@
#include <boost/numeric/bindings/lapack/driver/hbevx.hpp>
#include <boost/numeric/bindings/lapack/driver/sbevx.hpp>
-#include <boost/numeric/ublas/matrix_proxy.hpp>
-#include <boost/numeric/ublas/vector_proxy.hpp>
+#include <boost/numeric/bindings/ublas/matrix_proxy.hpp>
+#include <boost/numeric/bindings/ublas/vector_proxy.hpp>
#include <boost/numeric/bindings/ublas/matrix.hpp>
#include <boost/numeric/bindings/ublas/vector.hpp>
#include <boost/numeric/bindings/ublas/banded.hpp>
@@ -27,22 +27,21 @@
namespace ublas = boost::numeric::ublas;
namespace lapack = boost::numeric::bindings::lapack;
-namespace traits = boost::numeric::bindings::traits;
+namespace bindings = boost::numeric::bindings;
struct apply_real {
template< typename MatrixAB, typename MatrixQ, typename VectorW,
typename MatrixZ, typename VectorIFAIL, typename Workspace >
- static inline integer_t hbevx( const char jobz, const char range,
- const integer_t n, const integer_t kd, MatrixAB& ab, MatrixQ& q,
- const typename traits::type_traits< typename traits::matrix_traits<
- MatrixAB >::value_type >::real_type vl,
- const typename traits::type_traits< typename traits::matrix_traits<
- MatrixAB >::value_type >::real_type vu, const integer_t il,
- const integer_t iu, const typename traits::type_traits<
- typename traits::matrix_traits<
- MatrixAB >::value_type >::real_type abstol, integer_t& m, VectorW& w,
+ static inline std::ptrdiff_t hbevx(
+ const char jobz, const char range, MatrixAB& ab, MatrixQ& q,
+ const typename bindings::remove_imaginary< typename bindings::value<
+ MatrixAB >::type >::type vl, const typename bindings::remove_imaginary<
+ typename bindings::value< MatrixAB >::type >::type vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const typename bindings::remove_imaginary< typename bindings::value<
+ MatrixAB >::type >::type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
- return lapack::sbevx( jobz, range, n, kd, ab, q, vl, vu,
+ return lapack::sbevx( jobz, range, ab, q, vl, vu,
il, iu, abstol, m, w, z, ifail, work );
}
};
@@ -50,17 +49,16 @@
struct apply_complex {
template< typename MatrixAB, typename MatrixQ, typename VectorW,
typename MatrixZ, typename VectorIFAIL, typename Workspace >
- static inline integer_t hbevx( const char jobz, const char range,
- const integer_t n, const integer_t kd, MatrixAB& ab, MatrixQ& q,
- const typename traits::type_traits< typename traits::matrix_traits<
- MatrixAB >::value_type >::real_type vl,
- const typename traits::type_traits< typename traits::matrix_traits<
- MatrixAB >::value_type >::real_type vu, const integer_t il,
- const integer_t iu, const typename traits::type_traits<
- typename traits::matrix_traits<
- MatrixAB >::value_type >::real_type abstol, integer_t& m, VectorW& w,
+ static inline std::ptrdiff_t hbevx(
+ const char jobz, const char range, MatrixAB& ab, MatrixQ& q,
+ const typename bindings::remove_imaginary< typename bindings::value<
+ MatrixAB >::type >::type vl, const typename bindings::remove_imaginary<
+ typename bindings::value< MatrixAB >::type >::type vu,
+ const fortran_int_t il, const fortran_int_t iu,
+ const typename bindings::remove_imaginary< typename bindings::value<
+ MatrixAB >::type >::type abstol, fortran_int_t& m, VectorW& w,
MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
- return lapack::hbevx( jobz, range, n, kd, ab, q, vl, vu,
+ return lapack::hbevx( jobz, range, ab, q, vl, vu,
il, iu, abstol, m, w, z, ifail, work );
}
};
@@ -110,12 +108,12 @@
// Compute Schur decomposition.
- apply_t::hbevx( 'V', 'A', bindings::size_column( h ), traits::matrix_upper_bandwidth( h ),
+ apply_t::hbevx( 'V', 'A',
h, q, vl, vu, il, iu, abstol, m, e1, z, ifail, workspace ) ;
if (check_residual( h2, e1, z )) return 255 ;
- apply_t::hbevx( 'N', 'A', bindings::size_column( h2 ), traits::matrix_upper_bandwidth( h2 ),
+ apply_t::hbevx( 'N', 'A',
h2, q, vl, vu, il, iu, abstol, m, e2, z, ifail, workspace ) ;
if (norm_2( e1 - e2 ) > n * norm_2( e1 ) * std::numeric_limits< real_type >::epsilon()) return 255 ;
@@ -131,7 +129,7 @@
ublas::matrix_range< matrix_type> z_r( z, r, r );
ublas::vector<integer_t> ifail_r(n-2);
- apply_t::hbevx( 'V', 'A', bindings::size_column( h_r ), traits::matrix_upper_bandwidth( h_r ),
+ apply_t::hbevx( 'V', 'A',
h_r, q, vl, vu, il, iu, abstol, m, e_r, z_r, ifail_r, workspace ) ;
banded_range a2_r( a2, r, r );
Modified: sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_ptsv.cpp
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_ptsv.cpp (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_ptsv.cpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -8,7 +8,9 @@
#include "../../blas/test/random.hpp"
-#include <boost/numeric/bindings/lapack/ptsv.hpp>
+#include <boost/numeric/bindings/lapack/driver/ptsv.hpp>
+#include <boost/numeric/bindings/lapack/computational/pttrf.hpp>
+#include <boost/numeric/bindings/lapack/computational/pttrs.hpp>
#include <boost/numeric/bindings/ublas/matrix.hpp>
#include <boost/numeric/bindings/ublas/vector.hpp>
#include <boost/numeric/ublas/operation.hpp>
@@ -21,7 +23,23 @@
namespace ublas = boost::numeric::ublas;
namespace lapack = boost::numeric::bindings::lapack;
+namespace bindings = boost::numeric::bindings;
+struct apply_real {
+ template< typename VectorD, typename VectorE, typename MatrixB >
+ static inline std::ptrdiff_t pttrs( const char uplo, const VectorD& d,
+ const VectorE& e, MatrixB& b ) {
+ return lapack::pttrs( d, e, b );
+ }
+};
+
+struct apply_complex {
+ template< typename VectorD, typename VectorE, typename MatrixB >
+ static inline std::ptrdiff_t pttrs( const char uplo, const VectorD& d,
+ const VectorE& e, MatrixB& b ) {
+ return lapack::pttrs( uplo, d, e, b );
+ }
+};
template <typename B, typename X>
bool check_residual( B const& b, X const& x ) {
@@ -39,6 +57,7 @@
template <typename T>
int do_value_type() {
+ typedef typename boost::mpl::if_<boost::is_complex<T>, apply_complex, apply_real>::type apply_t;
const int n = 8 ;
typedef typename bindings::remove_imaginary<T>::type real_type ;
@@ -69,12 +88,12 @@
// Compute solve
x.assign( b ) ;
- if( lapack::pttrs( 'U', d, e, x ) ) return -2 ;
+ if( apply_t::pttrs( 'U', d, e, x ) ) return -2 ;
if (!check_residual(b,x)) return 1 ;
x.assign( b ) ;
- if( lapack::pttrs( 'L', d, e, x ) ) return -3 ;
+ if( apply_t::pttrs( 'L', d, e, x ) ) return -3 ;
if (!check_residual(b,x)) return 2 ;
Modified: sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_steqr.cpp
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_steqr.cpp (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_steqr.cpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -8,7 +8,7 @@
#include "../../blas/test/random.hpp"
-#include <boost/numeric/bindings/lapack/steqr.hpp>
+#include <boost/numeric/bindings/lapack/computational/steqr.hpp>
#include <boost/numeric/bindings/ublas/matrix.hpp>
#include <boost/numeric/bindings/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
@@ -19,6 +19,7 @@
namespace ublas = boost::numeric::ublas;
namespace lapack = boost::numeric::bindings::lapack;
+namespace bindings = boost::numeric::bindings;
template <typename T>
Modified: sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_sytrd.cpp
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_sytrd.cpp (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/lapack/test/ublas_sytrd.cpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -9,8 +9,9 @@
#include "../../blas/test/random.hpp"
-#include <boost/numeric/bindings/lapack/sytrd.hpp>
+#include <boost/numeric/bindings/lapack/computational/sytrd.hpp>
#include <boost/numeric/bindings/ublas/matrix.hpp>
+#include <boost/numeric/bindings/ublas/symmetric.hpp>
#include <boost/numeric/bindings/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <algorithm>
@@ -20,9 +21,10 @@
namespace ublas = boost::numeric::ublas;
namespace lapack = boost::numeric::bindings::lapack;
+namespace bindings = boost::numeric::bindings;
-template <typename T>
+template <typename T, typename UPLO>
int do_value_type() {
const int n = 10 ;
@@ -30,6 +32,7 @@
typedef std::complex< real_type > complex_type ;
typedef ublas::matrix<T, ublas::column_major> matrix_type ;
+ typedef ublas::symmetric_adaptor<matrix_type, UPLO> symmetric_type ;
typedef ublas::vector<T> vector_type ;
// Set matrix
@@ -49,7 +52,8 @@
}
// Compute eigendecomposition.
- lapack::sytrd( 'U', a, d, e, tau ) ;
+ symmetric_type s_a( a );
+ lapack::sytrd( s_a, d, e, tau ) ;
for ( int i=0; i<d.size(); ++i) {
if (std::abs( d(i) - 2.0 ) > 10 * std::numeric_limits<T>::epsilon() ) return 1 ;
@@ -65,8 +69,8 @@
int main() {
// Run tests for different value_types
- if (do_value_type<float>()) return 255;
- if (do_value_type<double>()) return 255;
+ if (do_value_type<float, ublas::upper>()) return 255;
+ if (do_value_type<double, ublas::upper>()) return 255;
std::cout << "Regression test succeeded\n" ;
return 0;
Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/pt.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/pt.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,11 @@
+$TEMPLATE[ptcon.all.N.trait]
+size,D
+$TEMPLATE[pteqr.all.N.trait]
+size,D
+$TEMPLATE[ptrfs.all.N.trait]
+size,D
+$TEMPLATE[pttrf.all.N.trait]
+size,D
+$TEMPLATE[pttrs.all.N.trait]
+size,D
+$TEMPLATE[end]
Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/steqr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/steqr.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,11 @@
+$TEMPLATE[steqr.all.N.trait]
+size,D
+$TEMPLATE[steqr.all.min_size_work.args]
+N, COMPZ
+$TEMPLATE[steqr.all.min_size_work]
+if ( compz == 'N' ) {
+ return 1;
+} else {
+ return std::max< $INTEGER_TYPE >( 1, 2*n-2 );
+}
+$TEMPLATE[end]
Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pt.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pt.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
@@ -0,0 +1,7 @@
+$TEMPLATE[ptsv.all.include_templates]
+lapack_solve_pivot0
+$TEMPLATE[ptsv.all.N.trait]
+size,D
+$TEMPLATE[ptsvx.all.N.trait]
+size,D
+$TEMPLATE[end]
Deleted: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ptsv.hpp
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ptsv.hpp 2010-01-14 20:05:31 EST (Thu, 14 Jan 2010)
+++ (empty file)
@@ -1,3 +0,0 @@
-$TEMPLATE[ptsv.all.include_templates]
-lapack_solve_pivot0
-$TEMPLATE[end]