[Boost-commit] svn:boost r58929 - sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver

Subject: [Boost-commit] svn:boost r58929 - sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver
From: rutger_at_[hidden]
Date: 2010-01-12 06:15:41

Author: rutger
Date: 2010-01-12 06:15:40 EST (Tue, 12 Jan 2010)
New Revision: 58929
URL: http://svn.boost.org/trac/boost/changeset/58929

Log:
fixed num_columns traits in sbev, hbev

Text files modified: 
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp |   134 ++++++++++++++++++++------------------- 
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp |   128 +++++++++++++++++++-------------------  
   2 files changed, 132 insertions(+), 130 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp	2010-01-12 06:15:40 EST (Tue, 12 Jan 2010)
@@ -97,9 +97,8 @@
     //
     template< typename MatrixAB, typename VectorW, typename MatrixZ,
             typename WORK, typename RWORK >
-    static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
-            MatrixAB& ab, VectorW& w, MatrixZ& z, detail::workspace2< WORK,
-            RWORK > work ) {
+    static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
+            MatrixZ& z, detail::workspace2< WORK, RWORK > work ) {
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -110,15 +109,17 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
         BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
-        BOOST_ASSERT( n >= 0 );
-        BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
-        BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+        BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+                size_column(ab) ));
+        BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+                size_column(ab) ));
+        BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth_upper(ab) );
-        return detail::hbev( jobz, uplo(), n, bandwidth_upper(ab),
-                begin_value(ab), stride_major(ab), begin_value(w),
-                begin_value(z), stride_major(z),
+        return detail::hbev( jobz, uplo(), size_column(ab),
+                bandwidth_upper(ab), begin_value(ab), stride_major(ab),
+                begin_value(w), begin_value(z), stride_major(z),
                 begin_value(work.select(value_type())),
                 begin_value(work.select(real_type())) );
     }
@@ -131,12 +132,14 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB, typename VectorW, typename MatrixZ >
-    static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
-            MatrixAB& ab, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+    static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
+            MatrixZ& z, minimal_workspace work ) {
         typedef typename result_of::data_side< MatrixAB >::type uplo;
-        bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
-        bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
-        return invoke( jobz, n, ab, w, z, workspace( tmp_work, tmp_rwork ) );
+        bindings::detail::array< value_type > tmp_work( min_size_work(
+                size_column(ab) ) );
+        bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+                size_column(ab) ) );
+        return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_rwork ) );
     }
 
     //
@@ -147,10 +150,10 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB, typename VectorW, typename MatrixZ >
-    static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
-            MatrixAB& ab, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+    static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
+            MatrixZ& z, optimal_workspace work ) {
         typedef typename result_of::data_side< MatrixAB >::type uplo;
-        return invoke( jobz, n, ab, w, z, minimal_workspace() );
+        return invoke( jobz, ab, w, z, minimal_workspace() );
     }
 
     //
@@ -189,10 +192,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab, VectorW& w,
+        MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -203,10 +206,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab, VectorW& w,
+        MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -218,10 +221,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -232,10 +235,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -247,10 +250,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -261,10 +264,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -276,10 +279,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -290,10 +293,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -305,10 +308,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab, VectorW& w,
+        const MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -319,10 +322,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab, VectorW& w,
+        const MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -334,10 +337,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, const MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -348,10 +351,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, const MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -363,10 +366,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -377,10 +380,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -392,11 +395,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, const MatrixZ& z,
-        Workspace work ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z, Workspace work ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -407,10 +409,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z ) {
     return hbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp	2010-01-12 06:15:40 EST (Tue, 12 Jan 2010)
@@ -95,9 +95,8 @@
     //
     template< typename MatrixAB, typename VectorW, typename MatrixZ,
             typename WORK >
-    static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
-            MatrixAB& ab, VectorW& w, MatrixZ& z, detail::workspace1<
-            WORK > work ) {
+    static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
+            MatrixZ& z, detail::workspace1< WORK > work ) {
         typedef typename result_of::data_side< MatrixAB >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -112,14 +111,15 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
         BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
-        BOOST_ASSERT( n >= 0 );
-        BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+        BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+                size_column(ab) ));
+        BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth_upper(ab) );
-        return detail::sbev( jobz, uplo(), n, bandwidth_upper(ab),
-                begin_value(ab), stride_major(ab), begin_value(w),
-                begin_value(z), stride_major(z),
+        return detail::sbev( jobz, uplo(), size_column(ab),
+                bandwidth_upper(ab), begin_value(ab), stride_major(ab),
+                begin_value(w), begin_value(z), stride_major(z),
                 begin_value(work.select(real_type())) );
     }
 
@@ -131,11 +131,12 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB, typename VectorW, typename MatrixZ >
-    static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
-            MatrixAB& ab, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+    static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
+            MatrixZ& z, minimal_workspace work ) {
         typedef typename result_of::data_side< MatrixAB >::type uplo;
-        bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
-        return invoke( jobz, n, ab, w, z, workspace( tmp_work ) );
+        bindings::detail::array< real_type > tmp_work( min_size_work(
+                size_column(ab) ) );
+        return invoke( jobz, ab, w, z, workspace( tmp_work ) );
     }
 
     //
@@ -146,10 +147,10 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB, typename VectorW, typename MatrixZ >
-    static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
-            MatrixAB& ab, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+    static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w,
+            MatrixZ& z, optimal_workspace work ) {
         typedef typename result_of::data_side< MatrixAB >::type uplo;
-        return invoke( jobz, n, ab, w, z, minimal_workspace() );
+        return invoke( jobz, ab, w, z, minimal_workspace() );
     }
 
     //
@@ -180,10 +181,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab, VectorW& w,
+        MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -194,10 +195,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab, VectorW& w,
+        MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -209,10 +210,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -223,10 +224,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -238,10 +239,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -252,10 +253,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -267,10 +268,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -281,10 +282,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -296,10 +297,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab, VectorW& w,
+        const MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -310,10 +311,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab, VectorW& w,
+        const MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -325,10 +326,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, const MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -339,10 +340,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        VectorW& w, const MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -354,10 +355,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -368,10 +369,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        MatrixAB& ab, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 //
@@ -383,11 +384,10 @@
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ,
         typename Workspace >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, const MatrixZ& z,
-        Workspace work ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z, Workspace work ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, work );
+            ab, w, z, work );
 }
 
 //
@@ -398,10 +398,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t sbev( const char jobz, const fortran_int_t n,
-        const MatrixAB& ab, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t sbev( const char jobz, const MatrixAB& ab,
+        const VectorW& w, const MatrixZ& z ) {
     return sbev_impl< typename value< MatrixAB >::type >::invoke( jobz,
-            n, ab, w, z, optimal_workspace() );
+            ab, w, z, optimal_workspace() );
 }
 
 } // namespace lapack