[Boost-commit] svn:boost r64402 - in sandbox/numeric_bindings: boost/numeric/bindings/lapack/driver libs/numeric/bindings/doc libs/numeric/bindings/doc/lapack/driver libs/numeric/bindings/tools

Subject: [Boost-commit] svn:boost r64402 - in sandbox/numeric_bindings: boost/numeric/bindings/lapack/driver libs/numeric/bindings/doc libs/numeric/bindings/doc/lapack/driver libs/numeric/bindings/tools
From: thomas.klimpel_at_[hidden]
Date: 2010-07-27 19:40:00

Author: klimpel
Date: 2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
New Revision: 64402
URL: http://svn.boost.org/trac/boost/changeset/64402

Log:
intermediate checkin
- updated doc/Jamfile to be able to build html doc with current release branch
- parse "The dimension of the matrix pencil (A,B)" correctly enough for sspgvx.f and ssygvx.f
- still haven't solved how to parse ssbevd.f correctly enough, even so it seems to be just an obvious typo in the documentation
- still haven't found the macro to turn off auto-linking on windows (that's a new problem created by boost-serialization since ~July 2 on trunk and July 9 on release branch)

Text files modified: 
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp    |   462 ++------------------------------------- 
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp    |   463 ++------------------------------------- 
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp    |   269 +++++++++++-----------                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp    |   347 ++++++++++++++---------------           
   sandbox/numeric_bindings/libs/numeric/bindings/doc/Jamfile                 |     4                                         
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hegvx.qbk |    10                                         
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hpgvx.qbk |    10                                         
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/spgvx.qbk |     8                                         
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/sygvx.qbk |     8                                         
   sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py             |     2                                         
   10 files changed, 384 insertions(+), 1199 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -163,8 +163,8 @@
             typename MatrixZ, typename VectorIFAIL, typename WORK,
             typename IWORK >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixA& a, MatrixB& b, const real_type vl, const real_type vu,
+            const char jobz, const char range, MatrixA& a, MatrixB& b,
+            const real_type vl, const real_type vu,
             const fortran_int_t il, const fortran_int_t iu,
             const real_type abstol, fortran_int_t& m, VectorW& w,
             MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK,
@@ -191,11 +191,12 @@
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
-        BOOST_ASSERT( bindings::size(w) >= n );
+        BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
         BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
-                min_size_iwork( n ));
+                min_size_iwork( bindings::size_column(a) ));
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
-                min_size_work( n ));
+                min_size_work( bindings::size_column(a) ));
+        BOOST_ASSERT( bindings::size_column(a) >= 0 );
         BOOST_ASSERT( bindings::size_minor(a) == 1 ||
                 bindings::stride_minor(a) == 1 );
         BOOST_ASSERT( bindings::size_minor(b) == 1 ||
@@ -203,17 +204,17 @@
         BOOST_ASSERT( bindings::size_minor(z) == 1 ||
                 bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
-                n) );
+                bindings::size_column(a)) );
         BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
-                n) );
+                bindings::size_column(a)) );
         BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
-        BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
-        return detail::hegvx( itype, jobz, range, uplo(), n,
-                bindings::begin_value(a), bindings::stride_major(a),
-                bindings::begin_value(b), bindings::stride_major(b), vl, vu,
-                il, iu, abstol, m, bindings::begin_value(w),
-                bindings::begin_value(z), bindings::stride_major(z),
+        return detail::hegvx( itype, jobz, range, uplo(),
+                bindings::size_column(a), bindings::begin_value(a),
+                bindings::stride_major(a), bindings::begin_value(b),
+                bindings::stride_major(b), vl, vu, il, iu, abstol, m,
+                bindings::begin_value(w), bindings::begin_value(z),
+                bindings::stride_major(z),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())),
                 bindings::begin_value(work.select(fortran_int_t())),
@@ -230,18 +231,19 @@
     template< typename MatrixA, typename MatrixB, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixA& a, MatrixB& b, const real_type vl, const real_type vu,
+            const char jobz, const char range, MatrixA& a, MatrixB& b,
+            const real_type vl, const real_type vu,
             const fortran_int_t il, const fortran_int_t iu,
             const real_type abstol, fortran_int_t& m, VectorW& w,
             MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixA >::type uplo;
-        bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+        bindings::detail::array< real_type > tmp_work( min_size_work(
+                bindings::size_column(a) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
-                min_size_iwork( n ) );
-        return invoke( itype, jobz, range, n, a, b, vl, vu, il, iu, abstol, m,
-                w, z, ifail, workspace( tmp_work, tmp_iwork ) );
+                min_size_iwork( bindings::size_column(a) ) );
+        return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w,
+                z, ifail, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -254,8 +256,8 @@
     template< typename MatrixA, typename MatrixB, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixA& a, MatrixB& b, const real_type vl, const real_type vu,
+            const char jobz, const char range, MatrixA& a, MatrixB& b,
+            const real_type vl, const real_type vu,
             const fortran_int_t il, const fortran_int_t iu,
             const real_type abstol, fortran_int_t& m, VectorW& w,
             MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) {
@@ -263,18 +265,19 @@
         typedef typename result_of::uplo_tag< MatrixA >::type uplo;
         real_type opt_size_work;
         bindings::detail::array< fortran_int_t > tmp_iwork(
-                min_size_iwork( n ) );
-        detail::hegvx( itype, jobz, range, uplo(), n,
-                bindings::begin_value(a), bindings::stride_major(a),
-                bindings::begin_value(b), bindings::stride_major(b), vl, vu,
-                il, iu, abstol, m, bindings::begin_value(w),
-                bindings::begin_value(z), bindings::stride_major(z),
-                &opt_size_work, -1, bindings::begin_value(tmp_iwork),
+                min_size_iwork( bindings::size_column(a) ) );
+        detail::hegvx( itype, jobz, range, uplo(),
+                bindings::size_column(a), bindings::begin_value(a),
+                bindings::stride_major(a), bindings::begin_value(b),
+                bindings::stride_major(b), vl, vu, il, iu, abstol, m,
+                bindings::begin_value(w), bindings::begin_value(z),
+                bindings::stride_major(z), &opt_size_work, -1,
+                bindings::begin_value(tmp_iwork),
                 bindings::begin_value(ifail) );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
-        return invoke( itype, jobz, range, n, a, b, vl, vu, il, iu, abstol, m,
-                w, z, ifail, workspace( tmp_work, tmp_iwork ) );
+        return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w,
+                z, ifail, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -480,405 +483,6 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * MatrixB&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * MatrixB&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * MatrixB&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * const MatrixB&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * const MatrixB&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * const MatrixB&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * const MatrixB&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * MatrixB&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * MatrixB&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * MatrixB&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * MatrixB&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * const MatrixB&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * const MatrixB&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * const MatrixB&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hegvx. Its overload differs for
-// * const MatrixA&
-// * const MatrixB&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hegvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-//
-// Overloaded function for hegvx. Its overload differs for
-// * MatrixA&
-// * MatrixB&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixA, typename MatrixB, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hegvx( const fortran_int_t itype, const char jobz, const char range,
         MatrixA& a, MatrixB& b, const typename remove_imaginary<
         typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -156,12 +156,12 @@
             typename MatrixZ, typename VectorIFAIL, typename WORK,
             typename IWORK >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixAP& ap, MatrixBP& bp, const real_type vl,
-            const real_type vu, const fortran_int_t il,
-            const fortran_int_t iu, const real_type abstol,
-            fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
-            detail::workspace2< WORK, IWORK > work ) {
+            const char jobz, const char range, MatrixAP& ap, MatrixBP& bp,
+            const real_type vl, const real_type vu,
+            const fortran_int_t il, const fortran_int_t iu,
+            const real_type abstol, fortran_int_t& m, VectorW& w,
+            MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK,
+            IWORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) );
@@ -182,20 +182,21 @@
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
-        BOOST_ASSERT( bindings::size(w) >= n );
+        BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ap) );
         BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
-                min_size_iwork( n ));
+                min_size_iwork( bindings::size_column(ap) ));
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
-                min_size_work( n ));
+                min_size_work( bindings::size_column(ap) ));
+        BOOST_ASSERT( bindings::size_column(ap) >= 0 );
         BOOST_ASSERT( bindings::size_minor(z) == 1 ||
                 bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
-        BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
-        return detail::hpgvx( itype, jobz, range, uplo(), n,
-                bindings::begin_value(ap), bindings::begin_value(bp), vl, vu,
-                il, iu, abstol, m, bindings::begin_value(w),
-                bindings::begin_value(z), bindings::stride_major(z),
+        return detail::hpgvx( itype, jobz, range, uplo(),
+                bindings::size_column(ap), bindings::begin_value(ap),
+                bindings::begin_value(bp), vl, vu, il, iu, abstol, m,
+                bindings::begin_value(w), bindings::begin_value(z),
+                bindings::stride_major(z),
                 bindings::begin_value(work.select(real_type())),
                 bindings::begin_value(work.select(fortran_int_t())),
                 bindings::begin_value(ifail) );
@@ -211,19 +212,19 @@
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixAP& ap, MatrixBP& bp, const real_type vl,
-            const real_type vu, const fortran_int_t il,
-            const fortran_int_t iu, const real_type abstol,
-            fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
-            minimal_workspace ) {
+            const char jobz, const char range, MatrixAP& ap, MatrixBP& bp,
+            const real_type vl, const real_type vu,
+            const fortran_int_t il, const fortran_int_t iu,
+            const real_type abstol, fortran_int_t& m, VectorW& w,
+            MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
-        bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+        bindings::detail::array< real_type > tmp_work( min_size_work(
+                bindings::size_column(ap) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
-                min_size_iwork( n ) );
-        return invoke( itype, jobz, range, n, ap, bp, vl, vu, il, iu, abstol,
-                m, w, z, ifail, workspace( tmp_work, tmp_iwork ) );
+                min_size_iwork( bindings::size_column(ap) ) );
+        return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m,
+                w, z, ifail, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -236,16 +237,15 @@
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixAP& ap, MatrixBP& bp, const real_type vl,
-            const real_type vu, const fortran_int_t il,
-            const fortran_int_t iu, const real_type abstol,
-            fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
-            optimal_workspace ) {
+            const char jobz, const char range, MatrixAP& ap, MatrixBP& bp,
+            const real_type vl, const real_type vu,
+            const fortran_int_t il, const fortran_int_t iu,
+            const real_type abstol, fortran_int_t& m, VectorW& w,
+            MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
-        return invoke( itype, jobz, range, n, ap, bp, vl, vu, il, iu, abstol,
-                m, w, z, ifail, minimal_workspace() );
+        return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m,
+                w, z, ifail, minimal_workspace() );
     }
 
     //
@@ -423,405 +423,6 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * MatrixBP&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * MatrixBP&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * MatrixBP&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * const MatrixBP&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * const MatrixBP&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * const MatrixBP&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * const MatrixBP&
-// * MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * MatrixBP&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * MatrixBP&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * MatrixBP&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * MatrixBP&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * const MatrixBP&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * const MatrixBP&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * const MatrixBP&
-// * const MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
-}
-
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * const MatrixAP&
-// * const MatrixBP&
-// * const MatrixZ&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL >
-inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
-    return hpgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
-}
-//
-// Overloaded function for hpgvx. Its overload differs for
-// * MatrixAP&
-// * MatrixBP&
-// * MatrixZ&
-// * User-defined workspace
-//
-template< typename MatrixAP, typename MatrixBP, typename VectorW,
-        typename MatrixZ, typename VectorIFAIL, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
-        std::ptrdiff_t >::type
-hpgvx( const fortran_int_t itype, const char jobz, const char range,
         MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
         typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -105,12 +105,12 @@
             typename MatrixZ, typename VectorIFAIL, typename WORK,
             typename IWORK >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixAP& ap, MatrixBP& bp, const real_type vl,
-            const real_type vu, const fortran_int_t il,
-            const fortran_int_t iu, const real_type abstol,
-            fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
-            detail::workspace2< WORK, IWORK > work ) {
+            const char jobz, const char range, MatrixAP& ap, MatrixBP& bp,
+            const real_type vl, const real_type vu,
+            const fortran_int_t il, const fortran_int_t iu,
+            const real_type abstol, fortran_int_t& m, VectorW& w,
+            MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK,
+            IWORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) );
@@ -131,20 +131,21 @@
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
-        BOOST_ASSERT( bindings::size(w) >= n );
+        BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ap) );
         BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
-                min_size_iwork( n ));
+                min_size_iwork( bindings::size_column(ap) ));
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
-                min_size_work( n ));
+                min_size_work( bindings::size_column(ap) ));
+        BOOST_ASSERT( bindings::size_column(ap) >= 0 );
         BOOST_ASSERT( bindings::size_minor(z) == 1 ||
                 bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
-        BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
-        return detail::spgvx( itype, jobz, range, uplo(), n,
-                bindings::begin_value(ap), bindings::begin_value(bp), vl, vu,
-                il, iu, abstol, m, bindings::begin_value(w),
-                bindings::begin_value(z), bindings::stride_major(z),
+        return detail::spgvx( itype, jobz, range, uplo(),
+                bindings::size_column(ap), bindings::begin_value(ap),
+                bindings::begin_value(bp), vl, vu, il, iu, abstol, m,
+                bindings::begin_value(w), bindings::begin_value(z),
+                bindings::stride_major(z),
                 bindings::begin_value(work.select(real_type())),
                 bindings::begin_value(work.select(fortran_int_t())),
                 bindings::begin_value(ifail) );
@@ -160,19 +161,19 @@
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixAP& ap, MatrixBP& bp, const real_type vl,
-            const real_type vu, const fortran_int_t il,
-            const fortran_int_t iu, const real_type abstol,
-            fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
-            minimal_workspace ) {
+            const char jobz, const char range, MatrixAP& ap, MatrixBP& bp,
+            const real_type vl, const real_type vu,
+            const fortran_int_t il, const fortran_int_t iu,
+            const real_type abstol, fortran_int_t& m, VectorW& w,
+            MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
-        bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+        bindings::detail::array< real_type > tmp_work( min_size_work(
+                bindings::size_column(ap) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
-                min_size_iwork( n ) );
-        return invoke( itype, jobz, range, n, ap, bp, vl, vu, il, iu, abstol,
-                m, w, z, ifail, workspace( tmp_work, tmp_iwork ) );
+                min_size_iwork( bindings::size_column(ap) ) );
+        return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m,
+                w, z, ifail, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -185,16 +186,15 @@
     template< typename MatrixAP, typename MatrixBP, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixAP& ap, MatrixBP& bp, const real_type vl,
-            const real_type vu, const fortran_int_t il,
-            const fortran_int_t iu, const real_type abstol,
-            fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
-            optimal_workspace ) {
+            const char jobz, const char range, MatrixAP& ap, MatrixBP& bp,
+            const real_type vl, const real_type vu,
+            const fortran_int_t il, const fortran_int_t iu,
+            const real_type abstol, fortran_int_t& m, VectorW& w,
+            MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
-        return invoke( itype, jobz, range, n, ap, bp, vl, vu, il, iu, abstol,
-                m, w, z, ifail, minimal_workspace() );
+        return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m,
+                w, z, ifail, minimal_workspace() );
     }
 
     //
@@ -236,16 +236,16 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
+        MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -261,16 +261,15 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -286,16 +285,16 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
+        const MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -311,16 +310,15 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
+        const MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -336,16 +334,16 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixAP& ap, const MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -361,16 +359,15 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
+        MatrixAP& ap, const MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -386,7 +383,7 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
+        const MatrixAP& ap, const MatrixBP& bp,
         const typename remove_imaginary< typename bindings::value_type<
         MatrixAP >::type >::type vl, const typename remove_imaginary<
         typename bindings::value_type< MatrixAP >::type >::type vu,
@@ -395,7 +392,7 @@
         MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
         MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -411,7 +408,7 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
+        const MatrixAP& ap, const MatrixBP& bp,
         const typename remove_imaginary< typename bindings::value_type<
         MatrixAP >::type >::type vl, const typename remove_imaginary<
         typename bindings::value_type< MatrixAP >::type >::type vu,
@@ -420,7 +417,7 @@
         MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
         MatrixZ& z, VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -436,16 +433,16 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
+        MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -461,16 +458,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -486,16 +483,16 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
+        const MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -511,16 +508,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, MatrixBP& bp,
+        const MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -536,16 +533,16 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixAP& ap, const MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -561,16 +558,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixAP& ap, const MatrixBP& bp,
+        MatrixAP& ap, const MatrixBP& bp, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixAP >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixAP >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixAP >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
@@ -586,7 +583,7 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
+        const MatrixAP& ap, const MatrixBP& bp,
         const typename remove_imaginary< typename bindings::value_type<
         MatrixAP >::type >::type vl, const typename remove_imaginary<
         typename bindings::value_type< MatrixAP >::type >::type vu,
@@ -595,7 +592,7 @@
         MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
         const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, work );
 }
 
@@ -611,7 +608,7 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 spgvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixAP& ap, const MatrixBP& bp,
+        const MatrixAP& ap, const MatrixBP& bp,
         const typename remove_imaginary< typename bindings::value_type<
         MatrixAP >::type >::type vl, const typename remove_imaginary<
         typename bindings::value_type< MatrixAP >::type >::type vu,
@@ -620,7 +617,7 @@
         MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
         const MatrixZ& z, VectorIFAIL& ifail ) {
     return spgvx_impl< typename bindings::value_type<
-            MatrixAP >::type >::invoke( itype, jobz, range, n, ap, bp, vl, vu,
+            MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu,
             il, iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -110,8 +110,8 @@
             typename MatrixZ, typename VectorIFAIL, typename WORK,
             typename IWORK >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixA& a, MatrixB& b, const real_type vl, const real_type vu,
+            const char jobz, const char range, MatrixA& a, MatrixB& b,
+            const real_type vl, const real_type vu,
             const fortran_int_t il, const fortran_int_t iu,
             const real_type abstol, fortran_int_t& m, VectorW& w,
             MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK,
@@ -138,11 +138,12 @@
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
-        BOOST_ASSERT( bindings::size(w) >= n );
+        BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) );
         BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
-                min_size_iwork( n ));
+                min_size_iwork( bindings::size_column(a) ));
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
-                min_size_work( n ));
+                min_size_work( bindings::size_column(a) ));
+        BOOST_ASSERT( bindings::size_column(a) >= 0 );
         BOOST_ASSERT( bindings::size_minor(a) == 1 ||
                 bindings::stride_minor(a) == 1 );
         BOOST_ASSERT( bindings::size_minor(b) == 1 ||
@@ -150,17 +151,17 @@
         BOOST_ASSERT( bindings::size_minor(z) == 1 ||
                 bindings::stride_minor(z) == 1 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
-                n) );
+                bindings::size_column(a)) );
         BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
-                n) );
+                bindings::size_column(a)) );
         BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
-        BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
-        return detail::sygvx( itype, jobz, range, uplo(), n,
-                bindings::begin_value(a), bindings::stride_major(a),
-                bindings::begin_value(b), bindings::stride_major(b), vl, vu,
-                il, iu, abstol, m, bindings::begin_value(w),
-                bindings::begin_value(z), bindings::stride_major(z),
+        return detail::sygvx( itype, jobz, range, uplo(),
+                bindings::size_column(a), bindings::begin_value(a),
+                bindings::stride_major(a), bindings::begin_value(b),
+                bindings::stride_major(b), vl, vu, il, iu, abstol, m,
+                bindings::begin_value(w), bindings::begin_value(z),
+                bindings::stride_major(z),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())),
                 bindings::begin_value(work.select(fortran_int_t())),
@@ -177,18 +178,19 @@
     template< typename MatrixA, typename MatrixB, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixA& a, MatrixB& b, const real_type vl, const real_type vu,
+            const char jobz, const char range, MatrixA& a, MatrixB& b,
+            const real_type vl, const real_type vu,
             const fortran_int_t il, const fortran_int_t iu,
             const real_type abstol, fortran_int_t& m, VectorW& w,
             MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::uplo_tag< MatrixA >::type uplo;
-        bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+        bindings::detail::array< real_type > tmp_work( min_size_work(
+                bindings::size_column(a) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
-                min_size_iwork( n ) );
-        return invoke( itype, jobz, range, n, a, b, vl, vu, il, iu, abstol, m,
-                w, z, ifail, workspace( tmp_work, tmp_iwork ) );
+                min_size_iwork( bindings::size_column(a) ) );
+        return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w,
+                z, ifail, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -201,8 +203,8 @@
     template< typename MatrixA, typename MatrixB, typename VectorW,
             typename MatrixZ, typename VectorIFAIL >
     static std::ptrdiff_t invoke( const fortran_int_t itype,
-            const char jobz, const char range, const fortran_int_t n,
-            MatrixA& a, MatrixB& b, const real_type vl, const real_type vu,
+            const char jobz, const char range, MatrixA& a, MatrixB& b,
+            const real_type vl, const real_type vu,
             const fortran_int_t il, const fortran_int_t iu,
             const real_type abstol, fortran_int_t& m, VectorW& w,
             MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) {
@@ -210,18 +212,19 @@
         typedef typename result_of::uplo_tag< MatrixA >::type uplo;
         real_type opt_size_work;
         bindings::detail::array< fortran_int_t > tmp_iwork(
-                min_size_iwork( n ) );
-        detail::sygvx( itype, jobz, range, uplo(), n,
-                bindings::begin_value(a), bindings::stride_major(a),
-                bindings::begin_value(b), bindings::stride_major(b), vl, vu,
-                il, iu, abstol, m, bindings::begin_value(w),
-                bindings::begin_value(z), bindings::stride_major(z),
-                &opt_size_work, -1, bindings::begin_value(tmp_iwork),
+                min_size_iwork( bindings::size_column(a) ) );
+        detail::sygvx( itype, jobz, range, uplo(),
+                bindings::size_column(a), bindings::begin_value(a),
+                bindings::stride_major(a), bindings::begin_value(b),
+                bindings::stride_major(b), vl, vu, il, iu, abstol, m,
+                bindings::begin_value(w), bindings::begin_value(z),
+                bindings::stride_major(z), &opt_size_work, -1,
+                bindings::begin_value(tmp_iwork),
                 bindings::begin_value(ifail) );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
-        return invoke( itype, jobz, range, n, a, b, vl, vu, il, iu, abstol, m,
-                w, z, ifail, workspace( tmp_work, tmp_iwork ) );
+        return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w,
+                z, ifail, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -263,17 +266,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
+        MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -288,17 +291,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -313,17 +315,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
+        const MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -338,17 +340,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        const MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -363,17 +364,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
+        MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -388,17 +389,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -413,17 +413,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
+        const MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail,
+        Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -438,17 +438,16 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        const MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -463,17 +462,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
+        MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -488,17 +487,17 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -513,17 +512,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
+        const MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -538,17 +537,17 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        const MatrixA& a, MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -563,17 +562,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
+        MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -588,17 +587,17 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 //
@@ -613,17 +612,17 @@
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
+        const MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail, Workspace work ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail, Workspace work ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, work );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, work );
 }
 
 //
@@ -638,17 +637,17 @@
 inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
         std::ptrdiff_t >::type
 sygvx( const fortran_int_t itype, const char jobz, const char range,
-        const fortran_int_t n, const MatrixA& a, const MatrixB& b,
-        const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type vl, const typename remove_imaginary<
-        typename bindings::value_type< MatrixA >::type >::type vu,
-        const fortran_int_t il, const fortran_int_t iu,
+        const MatrixA& a, const MatrixB& b, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type vl,
         const typename remove_imaginary< typename bindings::value_type<
-        MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w,
-        const MatrixZ& z, VectorIFAIL& ifail ) {
+        MatrixA >::type >::type vu, const fortran_int_t il,
+        const fortran_int_t iu, const typename remove_imaginary<
+        typename bindings::value_type< MatrixA >::type >::type abstol,
+        fortran_int_t& m, VectorW& w, const MatrixZ& z,
+        VectorIFAIL& ifail ) {
     return sygvx_impl< typename bindings::value_type<
-            MatrixA >::type >::invoke( itype, jobz, range, n, a, b, vl, vu,
-            il, iu, abstol, m, w, z, ifail, optimal_workspace() );
+            MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il,
+            iu, abstol, m, w, z, ifail, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/Jamfile
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/Jamfile	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/Jamfile	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -30,6 +30,6 @@
         <xsl:param>annotation.support=1
     ;
 
-stage html : $(BOOST_ROOT)/doc/html/boostbook.css ;
-stage html/images : [ path.glob $(BOOST_ROOT)/doc/html/images : *.png ] ;
+stage html : $(BOOST_ROOT)/doc/src/boostbook.css ;
+stage html/images : [ path.glob $(BOOST_ROOT)/doc/src/images : *.png ] ;
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hegvx.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hegvx.qbk	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hegvx.qbk	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -7,15 +7,7 @@
 [section hegvx]
 
 [heading Prototype]
-There are two prototypes of `hegvx` available, please see below.
-``
-hegvx( const int_t itype, const char jobz, const char range,
-        const int_t n, MatrixA& a, MatrixB& b, const Scalar >,
-        const Scalar >, const int_t il,
-        const int_t iu, const Scalar >, int_t& m,
-        VectorW& w, MatrixZ& z, VectorIFAIL& ifail );
-``
-
+There is one prototype of `hegvx` available, please see below.
 ``
 hegvx( const int_t itype, const char jobz, const char range,
         MatrixA& a, MatrixB& b, const Scalar >, const Scalar >,

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hpgvx.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hpgvx.qbk	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/hpgvx.qbk	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -7,15 +7,7 @@
 [section hpgvx]
 
 [heading Prototype]
-There are two prototypes of `hpgvx` available, please see below.
-``
-hpgvx( const int_t itype, const char jobz, const char range,
-        const int_t n, MatrixAP& ap, MatrixBP& bp, const Scalar >,
-        const Scalar >, const int_t il,
-        const int_t iu, const Scalar >, int_t& m,
-        VectorW& w, MatrixZ& z, VectorIFAIL& ifail );
-``
-
+There is one prototype of `hpgvx` available, please see below.
 ``
 hpgvx( const int_t itype, const char jobz, const char range,
         MatrixAP& ap, MatrixBP& bp, const Scalar >, const Scalar >,

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/spgvx.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/spgvx.qbk	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/spgvx.qbk	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -10,10 +10,10 @@
 There is one prototype of `spgvx` available, please see below.
 ``
 spgvx( const int_t itype, const char jobz, const char range,
-        const int_t n, MatrixAP& ap, MatrixBP& bp, const Scalar >,
-        const Scalar >, const int_t il,
-        const int_t iu, const Scalar >, int_t& m,
-        VectorW& w, MatrixZ& z, VectorIFAIL& ifail );
+        MatrixAP& ap, MatrixBP& bp, const Scalar >, const Scalar >,
+        const int_t il, const int_t iu,
+        const Scalar >, int_t& m, VectorW& w, MatrixZ& z,
+        VectorIFAIL& ifail );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/sygvx.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/sygvx.qbk	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/driver/sygvx.qbk	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -10,10 +10,10 @@
 There is one prototype of `sygvx` available, please see below.
 ``
 sygvx( const int_t itype, const char jobz, const char range,
-        const int_t n, MatrixA& a, MatrixB& b, const Scalar >,
-        const Scalar >, const int_t il,
-        const int_t iu, const Scalar >, int_t& m,
-        VectorW& w, MatrixZ& z, VectorIFAIL& ifail );
+        MatrixA& a, MatrixB& b, const Scalar >, const Scalar >,
+        const int_t il, const int_t iu,
+        const Scalar >, int_t& m, VectorW& w, MatrixZ& z,
+        VectorIFAIL& ifail );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py	2010-07-27 19:39:57 EDT (Tue, 27 Jul 2010)
@@ -1290,7 +1290,7 @@
         #
         # Try to detect fastest cases first (cheapest traits)
         #
-        match_matrix_traits = re.compile( '(sub|super|rows|columns|order)([\-]?diagonals|with|in|of|the|band|input|\s)+(matrix|matrices|\s)+' + \
+        match_matrix_traits = re.compile( '(sub|super|rows|columns|order)([\-]?diagonals|with|in|of|the|band|input|\s)+(matrix|pencil \(|matrices|\s)+' + \
             '([A-Z]+\s+and\s+[A-Z]+|[A-Z]+)', re.M | re.S ).findall( comment_block )
         match_banded_uplo = re.compile( '(number|of|sub|super|\s)+diagonals(if|\s)+UPLO', re.M | re.S ).findall( comment_block )
         if len( match_matrix_traits ) == 1: