Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r58945 - in sandbox/numeric_bindings/boost/numeric/bindings: lapack/auxiliary lapack/computational lapack/driver ublas
From: rutger_at_[hidden]
Date: 2010-01-12 11:28:45


Author: rutger
Date: 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
New Revision: 58945
URL: http://svn.boost.org/trac/boost/changeset/58945

Log:
Improved detection of the order of banded and packed matrices (no more need to add a great deal of .trait_of templates)

Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp | 31
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp | 33
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp | 31
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp | 33
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp | 31
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp | 33
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp | 102
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp | 259
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp | 25
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp | 420
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp | 117
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp | 28
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp | 20
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp | 36
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 92
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 241
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp | 24
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp | 6
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 6
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp | 86
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 40
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 226
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 17
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 17
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp | 27
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp | 17
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 85
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 241
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp | 28
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp | 24
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 80
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 184
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 27
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp | 164
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp | 367
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp | 9738 +++++++++++++++++------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp | 20
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp | 98
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp | 27
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cposv.hpp | 18
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp | 10926 +++++++++++++++++++--------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp | 36
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp | 24
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp | 32
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp | 136
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp | 944 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp | 254
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp | 264
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp | 867 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp | 144
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp | 1067 +--
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp | 8
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp | 217
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp | 903 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 6
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp | 2865 ++++-----
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp | 159
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp | 938 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp | 247
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp | 261
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp | 861 +-
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp | 24
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp | 211
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sposv.hpp | 14
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp | 12
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp | 134
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp | 16
   sandbox/numeric_bindings/boost/numeric/bindings/ublas/matrix_proxy.hpp | 1
   79 files changed, 16727 insertions(+), 18075 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/langb.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -118,17 +118,17 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename WORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ detail::workspace1< WORK > work ) {
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
                 bandwidth_upper(ab)+1 );
- return detail::langb( norm, n, bandwidth_lower(ab),
+ return detail::langb( norm, size_column(ab), bandwidth_lower(ab),
                 bandwidth_upper(ab), begin_value(ab), stride_major(ab),
                 begin_value(work.select(real_type())) );
     }
@@ -141,11 +141,11 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( norm, n, ab, workspace( tmp_work ) );
+ return invoke( norm, ab, workspace( tmp_work ) );
     }
 
     //
@@ -156,9 +156,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, optimal_workspace work ) {
- return invoke( norm, n, ab, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ optimal_workspace work ) {
+ return invoke( norm, ab, minimal_workspace() );
     }
 
     //
@@ -185,10 +185,10 @@
 // * User-defined workspace
 //
 template< typename MatrixAB, typename Workspace >
-inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
- const MatrixAB& ab, Workspace work ) {
+inline std::ptrdiff_t langb( const char norm, const MatrixAB& ab,
+ Workspace work ) {
     return langb_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, work );
+ ab, work );
 }
 
 //
@@ -196,10 +196,9 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t langb( const char norm, const fortran_int_t n,
- const MatrixAB& ab ) {
+inline std::ptrdiff_t langb( const char norm, const MatrixAB& ab ) {
     return langb_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, optimal_workspace() );
+ ab, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -95,16 +95,16 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename WORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ detail::workspace1< WORK > work ) {
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+1 );
- return detail::lanhb( norm, uplo(), n, bandwidth_lower(ab),
- begin_value(ab), stride_major(ab),
+ return detail::lanhb( norm, uplo(), size_column(ab),
+ bandwidth_lower(ab), begin_value(ab), stride_major(ab),
                 begin_value(work.select(real_type())) );
     }
 
@@ -116,11 +116,11 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( norm, n, ab, workspace( tmp_work ) );
+ return invoke( norm, ab, workspace( tmp_work ) );
     }
 
     //
@@ -131,9 +131,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, optimal_workspace work ) {
- return invoke( norm, n, ab, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ optimal_workspace work ) {
+ return invoke( norm, ab, minimal_workspace() );
     }
 
     //
@@ -160,10 +160,10 @@
 // * User-defined workspace
 //
 template< typename MatrixAB, typename Workspace >
-inline std::ptrdiff_t lanhb( const char norm, const fortran_int_t n,
- const MatrixAB& ab, Workspace work ) {
+inline std::ptrdiff_t lanhb( const char norm, const MatrixAB& ab,
+ Workspace work ) {
     return lanhb_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, work );
+ ab, work );
 }
 
 //
@@ -171,10 +171,9 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t lanhb( const char norm, const fortran_int_t n,
- const MatrixAB& ab ) {
+inline std::ptrdiff_t lanhb( const char norm, const MatrixAB& ab ) {
     return lanhb_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, optimal_workspace() );
+ ab, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -90,12 +90,12 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAP, typename WORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAP& ap, detail::workspace1< WORK > work ) {
- BOOST_ASSERT( n >= 0 );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ detail::workspace1< WORK > work ) {
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
- return detail::lanhp( norm, uplo(), n, begin_value(ap),
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::lanhp( norm, uplo(), size_column(ap), begin_value(ap),
                 begin_value(work.select(real_type())) );
     }
 
@@ -107,11 +107,11 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAP >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAP& ap, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( norm, n, ap, workspace( tmp_work ) );
+ return invoke( norm, ap, workspace( tmp_work ) );
     }
 
     //
@@ -122,9 +122,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAP >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAP& ap, optimal_workspace work ) {
- return invoke( norm, n, ap, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ optimal_workspace work ) {
+ return invoke( norm, ap, minimal_workspace() );
     }
 
     //
@@ -151,10 +151,10 @@
 // * User-defined workspace
 //
 template< typename MatrixAP, typename Workspace >
-inline std::ptrdiff_t lanhp( const char norm, const fortran_int_t n,
- const MatrixAP& ap, Workspace work ) {
+inline std::ptrdiff_t lanhp( const char norm, const MatrixAP& ap,
+ Workspace work ) {
     return lanhp_impl< typename value< MatrixAP >::type >::invoke( norm,
- n, ap, work );
+ ap, work );
 }
 
 //
@@ -162,10 +162,9 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAP >
-inline std::ptrdiff_t lanhp( const char norm, const fortran_int_t n,
- const MatrixAP& ap ) {
+inline std::ptrdiff_t lanhp( const char norm, const MatrixAP& ap ) {
     return lanhp_impl< typename value< MatrixAP >::type >::invoke( norm,
- n, ap, optimal_workspace() );
+ ap, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -125,16 +125,16 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename WORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ detail::workspace1< WORK > work ) {
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+1 );
- return detail::lansb( norm, uplo(), n, bandwidth_lower(ab),
- begin_value(ab), stride_major(ab),
+ return detail::lansb( norm, uplo(), size_column(ab),
+ bandwidth_lower(ab), begin_value(ab), stride_major(ab),
                 begin_value(work.select(real_type())) );
     }
 
@@ -146,11 +146,11 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( norm, n, ab, workspace( tmp_work ) );
+ return invoke( norm, ab, workspace( tmp_work ) );
     }
 
     //
@@ -161,9 +161,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, optimal_workspace work ) {
- return invoke( norm, n, ab, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ optimal_workspace work ) {
+ return invoke( norm, ab, minimal_workspace() );
     }
 
     //
@@ -190,10 +190,10 @@
 // * User-defined workspace
 //
 template< typename MatrixAB, typename Workspace >
-inline std::ptrdiff_t lansb( const char norm, const fortran_int_t n,
- const MatrixAB& ab, Workspace work ) {
+inline std::ptrdiff_t lansb( const char norm, const MatrixAB& ab,
+ Workspace work ) {
     return lansb_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, work );
+ ab, work );
 }
 
 //
@@ -201,10 +201,9 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t lansb( const char norm, const fortran_int_t n,
- const MatrixAB& ab ) {
+inline std::ptrdiff_t lansb( const char norm, const MatrixAB& ab ) {
     return lansb_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, optimal_workspace() );
+ ab, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -116,12 +116,12 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAP, typename WORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAP& ap, detail::workspace1< WORK > work ) {
- BOOST_ASSERT( n >= 0 );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ detail::workspace1< WORK > work ) {
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
- return detail::lansp( norm, uplo(), n, begin_value(ap),
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::lansp( norm, uplo(), size_column(ap), begin_value(ap),
                 begin_value(work.select(real_type())) );
     }
 
@@ -133,11 +133,11 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAP >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAP& ap, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( norm, n, ap, workspace( tmp_work ) );
+ return invoke( norm, ap, workspace( tmp_work ) );
     }
 
     //
@@ -148,9 +148,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAP >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAP& ap, optimal_workspace work ) {
- return invoke( norm, n, ap, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ optimal_workspace work ) {
+ return invoke( norm, ap, minimal_workspace() );
     }
 
     //
@@ -177,10 +177,10 @@
 // * User-defined workspace
 //
 template< typename MatrixAP, typename Workspace >
-inline std::ptrdiff_t lansp( const char norm, const fortran_int_t n,
- const MatrixAP& ap, Workspace work ) {
+inline std::ptrdiff_t lansp( const char norm, const MatrixAP& ap,
+ Workspace work ) {
     return lansp_impl< typename value< MatrixAP >::type >::invoke( norm,
- n, ap, work );
+ ap, work );
 }
 
 //
@@ -188,10 +188,9 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAP >
-inline std::ptrdiff_t lansp( const char norm, const fortran_int_t n,
- const MatrixAP& ap ) {
+inline std::ptrdiff_t lansp( const char norm, const MatrixAP& ap ) {
     return lansp_impl< typename value< MatrixAP >::type >::invoke( norm,
- n, ap, optimal_workspace() );
+ ap, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantb.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -129,17 +129,18 @@
     //
     template< typename MatrixAB, typename WORK >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t k,
- const MatrixAB& ab, detail::workspace1< WORK > work ) {
+ const fortran_int_t k, const MatrixAB& ab, detail::workspace1<
+ WORK > work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         BOOST_ASSERT( k >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= k+1 );
- return detail::lantb( norm, uplo, diag(), n, k, begin_value(ab),
- stride_major(ab), begin_value(work.select(real_type())) );
+ return detail::lantb( norm, uplo, diag(), size_column(ab), k,
+ begin_value(ab), stride_major(ab),
+ begin_value(work.select(real_type())) );
     }
 
     //
@@ -151,12 +152,12 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t k,
- const MatrixAB& ab, minimal_workspace work ) {
+ const fortran_int_t k, const MatrixAB& ab,
+ minimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( norm, uplo, n, k, ab, workspace( tmp_work ) );
+ return invoke( norm, uplo, k, ab, workspace( tmp_work ) );
     }
 
     //
@@ -168,10 +169,10 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t k,
- const MatrixAB& ab, optimal_workspace work ) {
+ const fortran_int_t k, const MatrixAB& ab,
+ optimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( norm, uplo, n, k, ab, minimal_workspace() );
+ return invoke( norm, uplo, k, ab, minimal_workspace() );
     }
 
     //
@@ -199,10 +200,9 @@
 //
 template< typename MatrixAB, typename Workspace >
 inline std::ptrdiff_t lantb( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t k,
- const MatrixAB& ab, Workspace work ) {
+ const fortran_int_t k, const MatrixAB& ab, Workspace work ) {
     return lantb_impl< typename value< MatrixAB >::type >::invoke( norm,
- uplo, n, k, ab, work );
+ uplo, k, ab, work );
 }
 
 //
@@ -211,10 +211,9 @@
 //
 template< typename MatrixAB >
 inline std::ptrdiff_t lantb( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t k,
- const MatrixAB& ab ) {
+ const fortran_int_t k, const MatrixAB& ab ) {
     return lantb_impl< typename value< MatrixAB >::type >::invoke( norm,
- uplo, n, k, ab, optimal_workspace() );
+ uplo, k, ab, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -137,20 +137,21 @@
     //
     template< typename MatrixAB, typename VectorIPIV, typename WORK,
             typename IWORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const real_type anorm,
- real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ detail::workspace2< WORK, IWORK > work ) {
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- BOOST_ASSERT( size(ipiv) >= n );
+ BOOST_ASSERT( size(ipiv) >= size_column(ab) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ min_size_iwork( size_column(ab) ));
+ 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( stride_major(ab) >= 2 );
- return detail::gbcon( norm, n, bandwidth_lower(ab),
+ return detail::gbcon( norm, size_column(ab), bandwidth_lower(ab),
                 bandwidth_upper(ab), begin_value(ab), stride_major(ab),
                 begin_value(ipiv), anorm, rcond,
                 begin_value(work.select(real_type())),
@@ -165,13 +166,14 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB, typename VectorIPIV >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const real_type anorm,
- real_type& rcond, minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( norm, n, ab, ipiv, anorm, rcond, workspace( tmp_work,
+ min_size_iwork( size_column(ab) ) );
+ return invoke( norm, ab, ipiv, anorm, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
@@ -183,10 +185,10 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB, typename VectorIPIV >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const real_type anorm,
- real_type& rcond, optimal_workspace work ) {
- return invoke( norm, n, ab, ipiv, anorm, rcond, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ optimal_workspace work ) {
+ return invoke( norm, ab, ipiv, anorm, rcond, minimal_workspace() );
     }
 
     //
@@ -223,19 +225,21 @@
     //
     template< typename MatrixAB, typename VectorIPIV, typename WORK,
             typename RWORK >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const real_type anorm,
- real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ detail::workspace2< WORK, RWORK > work ) {
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- BOOST_ASSERT( size(ipiv) >= n );
- 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(ipiv) >= size_column(ab) );
+ 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( stride_major(ab) >= 2 );
- return detail::gbcon( norm, n, bandwidth_lower(ab),
+ return detail::gbcon( norm, size_column(ab), bandwidth_lower(ab),
                 bandwidth_upper(ab), begin_value(ab), stride_major(ab),
                 begin_value(ipiv), anorm, rcond,
                 begin_value(work.select(value_type())),
@@ -250,12 +254,14 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB, typename VectorIPIV >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const real_type anorm,
- real_type& rcond, minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( norm, n, ab, ipiv, anorm, rcond, workspace( tmp_work,
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ minimal_workspace work ) {
+ 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( norm, ab, ipiv, anorm, rcond, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -267,10 +273,10 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB, typename VectorIPIV >
- static std::ptrdiff_t invoke( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const real_type anorm,
- real_type& rcond, optimal_workspace work ) {
- return invoke( norm, n, ab, ipiv, anorm, rcond, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ optimal_workspace work ) {
+ return invoke( norm, ab, ipiv, anorm, rcond, minimal_workspace() );
     }
 
     //
@@ -305,13 +311,13 @@
 // * User-defined workspace
 //
 template< typename MatrixAB, typename VectorIPIV, typename Workspace >
-inline std::ptrdiff_t gbcon( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv,
- const typename remove_imaginary< typename value<
- MatrixAB >::type >::type anorm, typename remove_imaginary<
- typename value< MatrixAB >::type >::type& rcond, Workspace work ) {
+inline std::ptrdiff_t gbcon( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const typename remove_imaginary<
+ typename value< MatrixAB >::type >::type anorm,
+ typename remove_imaginary< typename value<
+ MatrixAB >::type >::type& rcond, Workspace work ) {
     return gbcon_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, ipiv, anorm, rcond, work );
+ ab, ipiv, anorm, rcond, work );
 }
 
 //
@@ -319,13 +325,13 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename VectorIPIV >
-inline std::ptrdiff_t gbcon( const char norm, const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv,
- const typename remove_imaginary< typename value<
- MatrixAB >::type >::type anorm, typename remove_imaginary<
- typename value< MatrixAB >::type >::type& rcond ) {
+inline std::ptrdiff_t gbcon( const char norm, const MatrixAB& ab,
+ const VectorIPIV& ipiv, const typename remove_imaginary<
+ typename value< MatrixAB >::type >::type anorm,
+ typename remove_imaginary< typename value<
+ MatrixAB >::type >::type& rcond ) {
     return gbcon_impl< typename value< MatrixAB >::type >::invoke( norm,
- n, ab, ipiv, anorm, rcond, optimal_workspace() );
+ ab, ipiv, anorm, rcond, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -158,10 +158,10 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -187,13 +187,14 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
- BOOST_ASSERT( size(ipiv) >= n );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
+ BOOST_ASSERT( size(ipiv) >= size_column(ab) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ min_size_iwork( size_column(ab) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ab) ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -201,10 +202,12 @@
         BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
                 bandwidth_upper(ab)+1 );
         BOOST_ASSERT( stride_major(afb) >= 2 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gbrfs( trans(), n, bandwidth_lower(ab),
- bandwidth_upper(ab), size_column(x), begin_value(ab),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::gbrfs( trans(), size_column(ab), bandwidth_lower(ab),
+ bandwidth_upper(ab), size_column(b), begin_value(ab),
                 stride_major(ab), begin_value(afb), stride_major(afb),
                 begin_value(ipiv), begin_value(b), stride_major(b),
                 begin_value(x), stride_major(x), begin_value(ferr),
@@ -222,15 +225,15 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( n, ab, afb, ipiv, b, x, ferr, berr,
- workspace( tmp_work, tmp_iwork ) );
+ min_size_iwork( size_column(ab) ) );
+ return invoke( ab, afb, ipiv, b, x, ferr, berr, workspace( tmp_work,
+ tmp_iwork ) );
     }
 
     //
@@ -243,12 +246,10 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
- return invoke( n, ab, afb, ipiv, b, x, ferr, berr,
- minimal_workspace() );
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ return invoke( ab, afb, ipiv, b, x, ferr, berr, minimal_workspace() );
     }
 
     //
@@ -286,10 +287,10 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
                 typename remove_const< typename value<
@@ -311,12 +312,14 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
- BOOST_ASSERT( size(ipiv) >= n );
- 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_column(x) >= 0 );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
+ BOOST_ASSERT( size(ipiv) >= size_column(ab) );
+ 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_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -324,10 +327,12 @@
         BOOST_ASSERT( stride_major(ab) >= bandwidth_lower(ab)+
                 bandwidth_upper(ab)+1 );
         BOOST_ASSERT( stride_major(afb) >= 2 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gbrfs( trans(), n, bandwidth_lower(ab),
- bandwidth_upper(ab), size_column(x), begin_value(ab),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::gbrfs( trans(), size_column(ab), bandwidth_lower(ab),
+ bandwidth_upper(ab), size_column(b), begin_value(ab),
                 stride_major(ab), begin_value(afb), stride_major(afb),
                 begin_value(ipiv), begin_value(b), stride_major(b),
                 begin_value(x), stride_major(x), begin_value(ferr),
@@ -345,14 +350,15 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( n, ab, afb, ipiv, b, x, ferr, berr,
- workspace( tmp_work, tmp_rwork ) );
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ 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( ab, afb, ipiv, b, x, ferr, berr, workspace( tmp_work,
+ tmp_rwork ) );
     }
 
     //
@@ -365,12 +371,10 @@
     template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
             typename MatrixB, typename MatrixX, typename VectorFERR,
             typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
- return invoke( n, ab, afb, ipiv, b, x, ferr, berr,
- minimal_workspace() );
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ return invoke( ab, afb, ipiv, b, x, ferr, berr, minimal_workspace() );
     }
 
     //
@@ -410,11 +414,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -428,10 +431,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -445,11 +448,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -463,11 +465,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -481,11 +482,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -499,11 +499,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -517,11 +516,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -535,11 +533,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -553,11 +550,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -571,11 +567,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -589,11 +584,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -607,11 +601,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -625,11 +618,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -643,11 +635,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -661,11 +652,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, work );
 }
 
@@ -679,11 +669,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV,
         typename MatrixB, typename MatrixX, typename VectorFERR,
         typename VectorBERR >
-inline std::ptrdiff_t gbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return gbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return gbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, ipiv, b, x, ferr, berr, optimal_workspace() );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbtrs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -129,8 +129,8 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const VectorIPIV& ipiv,
+ MatrixB& b ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -138,14 +138,15 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(ipiv) >= n );
+ BOOST_ASSERT( size(ipiv) >= size_column(ab) );
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( stride_major(ab) >= 2 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gbtrs( trans(), n, bandwidth_lower(ab),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::gbtrs( trans(), size_column(ab), bandwidth_lower(ab),
                 bandwidth_upper(ab), size_column(b), begin_value(ab),
                 stride_major(ab), begin_value(ipiv), begin_value(b),
                 stride_major(b) );
@@ -168,9 +169,9 @@
 // * MatrixB&
 //
 template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
-inline std::ptrdiff_t gbtrs( const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, MatrixB& b ) {
- return gbtrs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbtrs( const MatrixAB& ab, const VectorIPIV& ipiv,
+ MatrixB& b ) {
+ return gbtrs_impl< typename value< MatrixAB >::type >::invoke( ab,
             ipiv, b );
 }
 
@@ -179,9 +180,9 @@
 // * const MatrixB&
 //
 template< typename MatrixAB, typename VectorIPIV, typename MatrixB >
-inline std::ptrdiff_t gbtrs( const fortran_int_t n,
- const MatrixAB& ab, const VectorIPIV& ipiv, const MatrixB& b ) {
- return gbtrs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t gbtrs( const MatrixAB& ab, const VectorIPIV& ipiv,
+ const MatrixB& b ) {
+ return gbtrs_impl< typename value< MatrixAB >::type >::invoke( ab,
             ipiv, b );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -177,13 +177,13 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= size_column_op(a, trans()) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( size_column_op(a, trans()) ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 size_column_op(a, trans()) ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
@@ -198,7 +198,7 @@
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column_op(a, trans())) );
         return detail::gerfs( trans(), size_column_op(a, trans()),
- size_column(x), begin_value(a), stride_major(a),
+ size_column(b), begin_value(a), stride_major(a),
                 begin_value(af), stride_major(af), begin_value(ipiv),
                 begin_value(b), stride_major(b), begin_value(x),
                 stride_major(x), begin_value(ferr), begin_value(berr),
@@ -304,13 +304,13 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= size_column_op(a, trans()) );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
                 size_column_op(a, trans()) ));
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 size_column_op(a, trans()) ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_column_op(a, trans()) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
@@ -325,7 +325,7 @@
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column_op(a, trans())) );
         return detail::gerfs( trans(), size_column_op(a, trans()),
- size_column(x), begin_value(a), stride_major(a),
+ size_column(b), begin_value(a), stride_major(a),
                 begin_value(af), stride_major(af), begin_value(ipiv),
                 begin_value(b), stride_major(b), begin_value(x),
                 stride_major(x), begin_value(ferr), begin_value(berr),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -133,10 +133,10 @@
     //
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE, typename WORK >
- static std::ptrdiff_t invoke( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale, detail::workspace1<
+ WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -154,15 +154,17 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorLSCALE >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorRSCALE >::value) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::ggbal( job, n, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), ilo, ihi,
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::ggbal( job, size_column(a), begin_value(a),
+ stride_major(a), begin_value(b), stride_major(b), ilo, ihi,
                 begin_value(lscale), begin_value(rscale),
                 begin_value(work.select(real_type())) );
     }
@@ -176,13 +178,13 @@
     //
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static std::ptrdiff_t invoke( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( job, n, a, b, ilo, ihi, lscale, rscale,
+ return invoke( job, a, b, ilo, ihi, lscale, rscale,
                 workspace( tmp_work ) );
     }
 
@@ -195,11 +197,11 @@
     //
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static std::ptrdiff_t invoke( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, optimal_workspace work ) {
- return invoke( job, n, a, b, ilo, ihi, lscale, rscale,
+ static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale,
+ optimal_workspace work ) {
+ return invoke( job, a, b, ilo, ihi, lscale, rscale,
                 minimal_workspace() );
     }
 
@@ -229,10 +231,10 @@
     //
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE, typename WORK >
- static std::ptrdiff_t invoke( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale, detail::workspace1<
+ WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorLSCALE >::type >::type,
                 typename remove_const< typename value<
@@ -246,15 +248,17 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorLSCALE >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorRSCALE >::value) );
         BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::ggbal( job, n, begin_value(a), stride_major(a),
- begin_value(b), stride_major(b), ilo, ihi,
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::ggbal( job, size_column(a), begin_value(a),
+ stride_major(a), begin_value(b), stride_major(b), ilo, ihi,
                 begin_value(lscale), begin_value(rscale),
                 begin_value(work.select(real_type())) );
     }
@@ -268,13 +272,13 @@
     //
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static std::ptrdiff_t invoke( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale,
+ minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
- return invoke( job, n, a, b, ilo, ihi, lscale, rscale,
+ return invoke( job, a, b, ilo, ihi, lscale, rscale,
                 workspace( tmp_work ) );
     }
 
@@ -287,11 +291,11 @@
     //
     template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
             typename VectorRSCALE >
- static std::ptrdiff_t invoke( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- VectorRSCALE& rscale, optimal_workspace work ) {
- return invoke( job, n, a, b, ilo, ihi, lscale, rscale,
+ static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale,
+ optimal_workspace work ) {
+ return invoke( job, a, b, ilo, ihi, lscale, rscale,
                 minimal_workspace() );
     }
 
@@ -324,12 +328,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale,
- Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -342,11 +345,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -359,12 +362,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale,
- Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -377,11 +379,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -394,12 +396,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale,
- Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -412,11 +413,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
+ VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -429,12 +430,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale,
- Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -447,11 +447,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -464,12 +464,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -482,12 +481,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -500,12 +498,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -518,12 +515,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -536,12 +532,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -554,12 +549,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -572,12 +566,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -590,12 +583,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -608,12 +600,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
         const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -626,12 +617,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
         const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -644,12 +634,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
         const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -662,12 +651,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
         const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -680,12 +668,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
         const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -698,12 +685,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale,
         const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -716,12 +702,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, const VectorRSCALE& rscale, Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -734,12 +719,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, VectorLSCALE& lscale,
- const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ VectorLSCALE& lscale, const VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -752,12 +736,12 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale,
+ Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -770,12 +754,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -788,12 +771,12 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale,
+ Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -806,12 +789,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a, MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -824,12 +806,12 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale,
+ Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -842,12 +824,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, MatrixA& a, const MatrixB& b,
+ fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 //
@@ -860,12 +841,12 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE, typename Workspace >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale, Workspace work ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, work );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale,
+ Workspace work ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, work );
 }
 
 //
@@ -878,12 +859,11 @@
 //
 template< typename MatrixA, typename MatrixB, typename VectorLSCALE,
         typename VectorRSCALE >
-inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, fortran_int_t& ilo,
- fortran_int_t& ihi, const VectorLSCALE& lscale,
- const VectorRSCALE& rscale ) {
- return ggbal_impl< typename value< MatrixA >::type >::invoke( job, n,
- a, b, ilo, ihi, lscale, rscale, optimal_workspace() );
+inline std::ptrdiff_t ggbal( const char job, const MatrixA& a,
+ const MatrixB& b, fortran_int_t& ilo, fortran_int_t& ihi,
+ const VectorLSCALE& lscale, const VectorRSCALE& rscale ) {
+ return ggbal_impl< typename value< MatrixA >::type >::invoke( job, a,
+ b, ilo, ihi, lscale, rscale, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gghrd.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -131,8 +131,8 @@
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
     static std::ptrdiff_t invoke( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, MatrixB& b, MatrixQ& q,
+ MatrixZ& z ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -151,17 +151,19 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
         BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' );
         BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::gghrd( compq, compz, n, ilo, size_column(a),
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z) );
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::gghrd( compq, compz, size_column(a), ilo,
+ size_column(a), begin_value(a), stride_major(a),
+ begin_value(b), stride_major(b), begin_value(q),
+ stride_major(q), begin_value(z), stride_major(z) );
     }
 
 };
@@ -186,10 +188,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- MatrixB& b, MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, MatrixB& b, MatrixQ& q,
+ MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -202,10 +204,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, MatrixB& b, MatrixQ& q,
+ MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -218,10 +220,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- const MatrixB& b, MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, const MatrixB& b, MatrixQ& q,
+ MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -234,10 +236,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, const MatrixB& b,
+ MatrixQ& q, MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -250,10 +252,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- MatrixB& b, const MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, MatrixB& b, const MatrixQ& q,
+ MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -266,10 +268,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, MatrixB& b,
+ const MatrixQ& q, MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -282,10 +284,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- const MatrixB& b, const MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, const MatrixB& b,
+ const MatrixQ& q, MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -298,10 +300,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, const MatrixB& b,
+ const MatrixQ& q, MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -314,10 +316,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- MatrixB& b, MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, MatrixB& b, MatrixQ& q,
+ const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -330,10 +332,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, MatrixB& b, MatrixQ& q,
+ const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -346,10 +348,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- const MatrixB& b, MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, const MatrixB& b, MatrixQ& q,
+ const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -362,10 +364,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, const MatrixB& b,
+ MatrixQ& q, const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -378,10 +380,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- MatrixB& b, const MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, MatrixB& b, const MatrixQ& q,
+ const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -394,10 +396,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, MatrixB& b,
+ const MatrixQ& q, const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -410,10 +412,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo, MatrixA& a,
- const MatrixB& b, const MatrixQ& q, const MatrixZ& z ) {
+ const fortran_int_t ilo, MatrixA& a, const MatrixB& b,
+ const MatrixQ& q, const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 //
@@ -426,11 +428,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t gghrd( const char compq, const char compz,
- const fortran_int_t n, const fortran_int_t ilo,
- const MatrixA& a, const MatrixB& b, const MatrixQ& q,
- const MatrixZ& z ) {
+ const fortran_int_t ilo, const MatrixA& a, const MatrixB& b,
+ const MatrixQ& q, const MatrixZ& z ) {
     return gghrd_impl< typename value< MatrixA >::type >::invoke( compq,
- compz, n, ilo, a, b, q, z );
+ compz, ilo, a, b, q, z );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -156,9 +156,9 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorTAUA >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
- BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(b),
+ BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
                 size_column(a)) );
- BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(b),
+ BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(a),
                 size_column(b)) );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
@@ -166,12 +166,12 @@
         BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_row(b) >= 0 );
+ BOOST_ASSERT( size_row(a) >= 0 );
         BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
+ size_row(a)) );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
- return detail::ggqrf( size_row(b), size_column(a), size_column(b),
+ size_row(a)) );
+ return detail::ggqrf( size_row(a), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 begin_value(work.select(real_type())),
@@ -206,7 +206,7 @@
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
         real_type opt_size_work;
- detail::ggqrf( size_row(b), size_column(a), size_column(b),
+ detail::ggqrf( size_row(a), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 &opt_size_work, -1 );
@@ -259,9 +259,9 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorTAUA >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
- BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(b),
+ BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
                 size_column(a)) );
- BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(b),
+ BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(a),
                 size_column(b)) );
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
@@ -269,12 +269,12 @@
         BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( size_row(b) >= 0 );
+ BOOST_ASSERT( size_row(a) >= 0 );
         BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
+ size_row(a)) );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
- size_row(b)) );
- return detail::ggqrf( size_row(b), size_column(a), size_column(b),
+ size_row(a)) );
+ return detail::ggqrf( size_row(a), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 begin_value(work.select(value_type())),
@@ -309,7 +309,7 @@
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
         value_type opt_size_work;
- detail::ggqrf( size_row(b), size_column(a), size_column(b),
+ detail::ggqrf( size_row(a), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 &opt_size_work, -1 );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -157,12 +157,12 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
         BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(b)) );
+ size_column(a)) );
         BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(b),
- size_column(b)) );
+ size_column(a)) );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(b) >= 0 );
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_row(a) >= 0 );
@@ -171,7 +171,7 @@
                 size_row(a)) );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
                 size_row(b)) );
- return detail::ggrqf( size_row(a), size_row(b), size_column(b),
+ return detail::ggrqf( size_row(a), size_row(b), size_column(a),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 begin_value(work.select(real_type())),
@@ -206,7 +206,7 @@
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
         real_type opt_size_work;
- detail::ggrqf( size_row(a), size_row(b), size_column(b),
+ detail::ggrqf( size_row(a), size_row(b), size_column(a),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 &opt_size_work, -1 );
@@ -260,12 +260,12 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorTAUB >::value) );
         BOOST_ASSERT( size(taua) >= std::min< std::ptrdiff_t >(size_row(a),
- size_column(b)) );
+ size_column(a)) );
         BOOST_ASSERT( size(taub) >= std::min< std::ptrdiff_t >(size_row(b),
- size_column(b)) );
+ size_column(a)) );
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(b) >= 0 );
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_row(a) >= 0 );
@@ -274,7 +274,7 @@
                 size_row(a)) );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
                 size_row(b)) );
- return detail::ggrqf( size_row(a), size_row(b), size_column(b),
+ return detail::ggrqf( size_row(a), size_row(b), size_column(a),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 begin_value(work.select(value_type())),
@@ -309,7 +309,7 @@
     static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b,
             VectorTAUB& taub, optimal_workspace work ) {
         value_type opt_size_work;
- detail::ggrqf( size_row(a), size_row(b), size_column(b),
+ detail::ggrqf( size_row(a), size_row(b), size_column(a),
                 begin_value(a), stride_major(a), begin_value(taua),
                 begin_value(b), stride_major(b), begin_value(taub),
                 &opt_size_work, -1 );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -186,12 +186,12 @@
         BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
         BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(b) ));
+ min_size_iwork( size_column(a) ));
         BOOST_ASSERT( size(work.select(real_type())) >=
- min_size_tau( size_column(b) ));
+ min_size_tau( size_column(a) ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
- size_column(b), size_row(a), size_row(b) ));
- BOOST_ASSERT( size_column(b) >= 0 );
+ size_column(a), size_row(a), size_row(b) ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
@@ -204,7 +204,7 @@
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
                 size_row(b)) );
         return detail::ggsvp( jobu, jobv, jobq, size_row(a), size_row(b),
- size_column(b), begin_value(a), stride_major(a),
+ size_column(a), begin_value(a), stride_major(a),
                 begin_value(b), stride_major(b), tola, tolb, k, l,
                 begin_value(u), stride_major(u), begin_value(v),
                 stride_major(v), begin_value(q), stride_major(q),
@@ -227,11 +227,11 @@
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace work ) {
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(b) ) );
+ min_size_iwork( size_column(a) ) );
         bindings::detail::array<
- real_type > tmp_tau( min_size_tau( size_column(b) ) );
+ real_type > tmp_tau( min_size_tau( size_column(a) ) );
         bindings::detail::array< real_type > tmp_work( min_size_work(
- size_column(b), size_row(a), size_row(b) ) );
+ size_column(a), size_row(a), size_row(b) ) );
         return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q,
                 workspace( tmp_iwork, tmp_tau, tmp_work ) );
     }
@@ -327,14 +327,14 @@
         BOOST_ASSERT( jobu == 'U' || jobu == 'N' );
         BOOST_ASSERT( jobv == 'V' || jobv == 'N' );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( size_column(b) ));
+ min_size_iwork( size_column(a) ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
- size_column(b) ));
+ size_column(a) ));
         BOOST_ASSERT( size(work.select(value_type())) >=
- min_size_tau( size_column(b) ));
+ min_size_tau( size_column(a) ));
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
- size_column(b), size_row(a), size_row(b) ));
- BOOST_ASSERT( size_column(b) >= 0 );
+ size_column(a), size_row(a), size_row(b) ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
@@ -347,7 +347,7 @@
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
                 size_row(b)) );
         return detail::ggsvp( jobu, jobv, jobq, size_row(a), size_row(b),
- size_column(b), begin_value(a), stride_major(a),
+ size_column(a), begin_value(a), stride_major(a),
                 begin_value(b), stride_major(b), tola, tolb, k, l,
                 begin_value(u), stride_major(u), begin_value(v),
                 stride_major(v), begin_value(q), stride_major(q),
@@ -371,13 +371,13 @@
             const real_type tolb, fortran_int_t& k, fortran_int_t& l,
             MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace work ) {
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( size_column(b) ) );
+ min_size_iwork( size_column(a) ) );
         bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
- size_column(b) ) );
+ size_column(a) ) );
         bindings::detail::array<
- value_type > tmp_tau( min_size_tau( size_column(b) ) );
+ value_type > tmp_tau( min_size_tau( size_column(a) ) );
         bindings::detail::array< value_type > tmp_work( min_size_work(
- size_column(b), size_row(a), size_row(b) ) );
+ size_column(a), size_row(a), size_row(b) ) );
         return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q,
                 workspace( tmp_iwork, tmp_rwork, tmp_tau, tmp_work ) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -102,9 +102,9 @@
     //
     template< typename MatrixAB, typename MatrixBB, typename MatrixX,
             typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x, detail::workspace2<
- WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, detail::workspace2< WORK,
+ RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -117,19 +117,22 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
         BOOST_ASSERT( bandwidth(bb, uplo()) >= bandwidth(bb, uplo()) );
- 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(bb) == 1 || stride_minor(bb) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
         BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' );
- return detail::hbgst( vect, uplo(), n, bandwidth(ab, uplo()),
- bandwidth(bb, uplo()), begin_value(ab), stride_major(ab),
- begin_value(bb), stride_major(bb), begin_value(x),
- stride_major(x), begin_value(work.select(value_type())),
+ return detail::hbgst( vect, uplo(), size_column(ab), bandwidth(ab,
+ uplo()), bandwidth(bb, uplo()), begin_value(ab),
+ stride_major(ab), begin_value(bb), stride_major(bb),
+ begin_value(x), stride_major(x),
+ begin_value(work.select(value_type())),
                 begin_value(work.select(real_type())) );
     }
 
@@ -141,12 +144,13 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( vect, n, ab, bb, x, workspace( tmp_work, tmp_rwork ) );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, minimal_workspace work ) {
+ 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( vect, ab, bb, x, workspace( tmp_work, tmp_rwork ) );
     }
 
     //
@@ -157,10 +161,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x,
- optimal_workspace work ) {
- return invoke( vect, n, ab, bb, x, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, optimal_workspace work ) {
+ return invoke( vect, ab, bb, x, minimal_workspace() );
     }
 
     //
@@ -198,10 +201,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x, Workspace work ) {
+inline std::ptrdiff_t hbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, Workspace work ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -211,10 +214,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x ) {
+inline std::ptrdiff_t hbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 //
@@ -225,10 +228,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, MatrixX& x, Workspace work ) {
+inline std::ptrdiff_t hbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, Workspace work ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -238,10 +241,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, MatrixX& x ) {
+inline std::ptrdiff_t hbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 //
@@ -252,10 +255,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, const MatrixX& x, Workspace work ) {
+inline std::ptrdiff_t hbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x, Workspace work ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -265,10 +268,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, const MatrixX& x ) {
+inline std::ptrdiff_t hbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 //
@@ -279,11 +282,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, const MatrixX& x,
- Workspace work ) {
+inline std::ptrdiff_t hbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x, Workspace work ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -293,10 +295,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t hbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, const MatrixX& x ) {
+inline std::ptrdiff_t hbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x ) {
     return hbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -99,9 +99,8 @@
     //
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename WORK >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorD >::type >::type,
                 typename remove_const< typename value<
@@ -115,15 +114,16 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(d) >= 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(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' );
- return detail::hbtrd( vect, uplo(), n, bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab), begin_value(d),
+ return detail::hbtrd( vect, uplo(), size_column(ab), bandwidth(ab,
+ uplo()), begin_value(ab), stride_major(ab), begin_value(d),
                 begin_value(e), begin_value(q), stride_major(q),
                 begin_value(work.select(value_type())) );
     }
@@ -137,11 +137,11 @@
     //
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- return invoke( vect, n, ab, d, e, q, workspace( tmp_work ) );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ab) ) );
+ return invoke( vect, ab, d, e, q, workspace( tmp_work ) );
     }
 
     //
@@ -153,10 +153,9 @@
     //
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- optimal_workspace work ) {
- return invoke( vect, n, ab, d, e, q, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, optimal_workspace work ) {
+ return invoke( vect, ab, d, e, q, minimal_workspace() );
     }
 
     //
@@ -188,10 +187,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -204,10 +203,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -220,11 +219,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -237,10 +235,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -253,11 +251,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -270,10 +267,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -286,11 +283,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -303,10 +299,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -319,11 +315,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -336,10 +331,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -352,11 +347,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -369,10 +363,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -385,11 +379,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -402,10 +395,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -418,11 +411,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -435,10 +427,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -451,11 +443,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, const MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -468,10 +459,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -484,11 +475,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, const MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -501,10 +491,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -517,11 +507,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -534,10 +523,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -550,11 +539,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -567,10 +555,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -583,11 +571,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, const MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -600,10 +587,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -616,11 +603,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, const MatrixQ& q, Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -633,10 +619,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -649,11 +635,11 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, const MatrixQ& q,
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q,
         Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -666,10 +652,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -682,11 +668,11 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e,
- const MatrixQ& q, Workspace work ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q,
+ Workspace work ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -699,11 +685,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t hbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e,
- const MatrixQ& q ) {
+inline std::ptrdiff_t hbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q ) {
     return hbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hegst.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -94,20 +94,22 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixA, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t itype,
- const fortran_int_t n, MatrixA& a, const MatrixB& b ) {
+ static std::ptrdiff_t invoke( const fortran_int_t itype, MatrixA& a,
+ const MatrixB& b ) {
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::hegst( itype, uplo(), n, begin_value(a),
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::hegst( itype, uplo(), size_column(a), begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b) );
     }
 
@@ -128,10 +130,10 @@
 // * MatrixA&
 //
 template< typename MatrixA, typename MatrixB >
-inline std::ptrdiff_t hegst( const fortran_int_t itype,
- const fortran_int_t n, MatrixA& a, const MatrixB& b ) {
+inline std::ptrdiff_t hegst( const fortran_int_t itype, MatrixA& a,
+ const MatrixB& b ) {
     return hegst_impl< typename value< MatrixA >::type >::invoke( itype,
- n, a, b );
+ a, b );
 }
 
 //
@@ -140,9 +142,9 @@
 //
 template< typename MatrixA, typename MatrixB >
 inline std::ptrdiff_t hegst( const fortran_int_t itype,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b ) {
+ const MatrixA& a, const MatrixB& b ) {
     return hegst_impl< typename value< MatrixA >::type >::invoke( itype,
- n, a, b );
+ a, b );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -128,14 +128,14 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= size_column(a) );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
                 size_column(a) ));
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 size_column(a) ));
         BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -148,7 +148,7 @@
                 size_column(a)) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column(a)) );
- return detail::herfs( uplo(), size_column(a), size_column(x),
+ return detail::herfs( uplo(), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(af),
                 stride_major(af), begin_value(ipiv), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -127,16 +127,16 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= n );
         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_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::hprfs( uplo(), n, size_column(x), begin_value(ap),
+ return detail::hprfs( uplo(), n, size_column(b), begin_value(ap),
                 begin_value(afp), begin_value(ipiv), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),
                 begin_value(ferr), begin_value(berr),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -133,18 +133,19 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const real_type anorm, real_type& rcond,
- detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ const real_type anorm, real_type& rcond, detail::workspace2< WORK,
+ IWORK > work ) {
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ min_size_iwork( size_column(ab) ));
+ 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( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbcon( uplo, n, bandwidth(ab, uplo()), begin_value(ab),
- stride_major(ab), anorm, rcond,
+ return detail::pbcon( uplo, size_column(ab), bandwidth(ab, uplo()),
+ begin_value(ab), stride_major(ab), anorm, rcond,
                 begin_value(work.select(real_type())),
                 begin_value(work.select(fortran_int_t())) );
     }
@@ -157,13 +158,13 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const real_type anorm, real_type& rcond,
- minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( uplo, n, ab, anorm, rcond, workspace( tmp_work,
+ min_size_iwork( size_column(ab) ) );
+ return invoke( uplo, ab, anorm, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
@@ -175,10 +176,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const real_type anorm, real_type& rcond,
- optimal_workspace work ) {
- return invoke( uplo, n, ab, anorm, rcond, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ return invoke( uplo, ab, anorm, rcond, minimal_workspace() );
     }
 
     //
@@ -214,17 +214,19 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const real_type anorm, real_type& rcond,
- detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ const real_type anorm, real_type& rcond, detail::workspace2< WORK,
+ RWORK > work ) {
         BOOST_ASSERT( bandwidth_upper(ab) >= 0 );
- 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( stride_major(ab) >= bandwidth_upper(ab)+1 );
- return detail::pbcon( uplo, n, bandwidth_upper(ab), begin_value(ab),
- stride_major(ab), anorm, rcond,
+ return detail::pbcon( uplo, size_column(ab), bandwidth_upper(ab),
+ begin_value(ab), stride_major(ab), anorm, rcond,
                 begin_value(work.select(value_type())),
                 begin_value(work.select(real_type())) );
     }
@@ -237,12 +239,13 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const real_type anorm, real_type& rcond,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( uplo, n, ab, anorm, rcond, workspace( tmp_work,
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ const real_type anorm, real_type& rcond, minimal_workspace work ) {
+ 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( uplo, ab, anorm, rcond, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -254,10 +257,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const real_type anorm, real_type& rcond,
- optimal_workspace work ) {
- return invoke( uplo, n, ab, anorm, rcond, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ const real_type anorm, real_type& rcond, optimal_workspace work ) {
+ return invoke( uplo, ab, anorm, rcond, minimal_workspace() );
     }
 
     //
@@ -292,12 +294,12 @@
 // * User-defined workspace
 //
 template< typename MatrixAB, typename Workspace >
-inline std::ptrdiff_t pbcon( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const typename remove_imaginary< typename value<
+inline std::ptrdiff_t pbcon( const char uplo, const MatrixAB& ab,
+ const typename remove_imaginary< typename value<
         MatrixAB >::type >::type anorm, typename remove_imaginary<
         typename value< MatrixAB >::type >::type& rcond, Workspace work ) {
     return pbcon_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, ab, anorm, rcond, work );
+ ab, anorm, rcond, work );
 }
 
 //
@@ -305,12 +307,12 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t pbcon( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const typename remove_imaginary< typename value<
+inline std::ptrdiff_t pbcon( const char uplo, const MatrixAB& ab,
+ const typename remove_imaginary< typename value<
         MatrixAB >::type >::type anorm, typename remove_imaginary<
         typename value< MatrixAB >::type >::type& rcond ) {
     return pbcon_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, ab, anorm, rcond, optimal_workspace() );
+ ab, anorm, rcond, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -132,19 +132,18 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename VectorS >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, VectorS& s, real_type& scond,
- real_type& amax ) {
+ static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s,
+ real_type& scond, real_type& amax ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 VectorS >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbequ( uplo(), n, bandwidth(ab, uplo()),
+ return detail::pbequ( uplo(), size_column(ab), bandwidth(ab, uplo()),
                 begin_value(ab), stride_major(ab), begin_value(s), scond,
                 amax );
     }
@@ -167,15 +166,14 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename VectorS >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, VectorS& s, real_type& scond,
- real_type& amax ) {
+ static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s,
+ real_type& scond, real_type& amax ) {
         BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbequ( uplo(), n, bandwidth(ab, uplo()),
+ return detail::pbequ( uplo(), size_column(ab), bandwidth(ab, uplo()),
                 begin_value(ab), stride_major(ab), begin_value(s), scond,
                 amax );
     }
@@ -197,13 +195,12 @@
 // * VectorS&
 //
 template< typename MatrixAB, typename VectorS >
-inline std::ptrdiff_t pbequ( const fortran_int_t n,
- const MatrixAB& ab, VectorS& s, typename remove_imaginary<
- typename value< MatrixAB >::type >::type& scond,
+inline std::ptrdiff_t pbequ( const MatrixAB& ab, VectorS& s,
         typename remove_imaginary< typename value<
- MatrixAB >::type >::type& amax ) {
- return pbequ_impl< typename value< MatrixAB >::type >::invoke( n, ab,
- s, scond, amax );
+ MatrixAB >::type >::type& scond, typename remove_imaginary<
+ typename value< MatrixAB >::type >::type& amax ) {
+ return pbequ_impl< typename value< MatrixAB >::type >::invoke( ab, s,
+ scond, amax );
 }
 
 //
@@ -211,13 +208,12 @@
 // * const VectorS&
 //
 template< typename MatrixAB, typename VectorS >
-inline std::ptrdiff_t pbequ( const fortran_int_t n,
- const MatrixAB& ab, const VectorS& s, typename remove_imaginary<
- typename value< MatrixAB >::type >::type& scond,
+inline std::ptrdiff_t pbequ( const MatrixAB& ab, const VectorS& s,
         typename remove_imaginary< typename value<
- MatrixAB >::type >::type& amax ) {
- return pbequ_impl< typename value< MatrixAB >::type >::invoke( n, ab,
- s, scond, amax );
+ MatrixAB >::type >::type& scond, typename remove_imaginary<
+ typename value< MatrixAB >::type >::type& amax ) {
+ return pbequ_impl< typename value< MatrixAB >::type >::invoke( ab, s,
+ scond, amax );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -150,9 +150,8 @@
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -178,22 +177,25 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ min_size_iwork( size_column(ab) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ab) ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
         BOOST_ASSERT( stride_major(afb) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pbrfs( uplo(), n, bandwidth(ab, uplo()),
- size_column(x), begin_value(ab), stride_major(ab),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::pbrfs( uplo(), size_column(ab), bandwidth(ab, uplo()),
+ size_column(b), begin_value(ab), stride_major(ab),
                 begin_value(afb), stride_major(afb), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),
                 begin_value(ferr), begin_value(berr),
@@ -210,14 +212,14 @@
     //
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( n, ab, afb, b, x, ferr, berr, workspace( tmp_work,
+ min_size_iwork( size_column(ab) ) );
+ return invoke( ab, afb, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
@@ -230,11 +232,10 @@
     //
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
- return invoke( n, ab, afb, b, x, ferr, berr, minimal_workspace() );
+ return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() );
     }
 
     //
@@ -272,9 +273,8 @@
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR,
             typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -296,21 +296,25 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
- 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_column(x) >= 0 );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
+ 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_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(afb) == 1 || stride_minor(afb) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
         BOOST_ASSERT( stride_major(afb) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pbrfs( uplo(), n, bandwidth(ab, uplo()),
- size_column(x), begin_value(ab), stride_major(ab),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::pbrfs( uplo(), size_column(ab), bandwidth(ab, uplo()),
+ size_column(b), begin_value(ab), stride_major(ab),
                 begin_value(afb), stride_major(afb), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),
                 begin_value(ferr), begin_value(berr),
@@ -327,13 +331,14 @@
     //
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( n, ab, afb, b, x, ferr, berr, workspace( tmp_work,
+ 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( ab, afb, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -346,11 +351,10 @@
     //
     template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
             typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
             optimal_workspace work ) {
- return invoke( n, ab, afb, b, x, ferr, berr, minimal_workspace() );
+ return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() );
     }
 
     //
@@ -390,10 +394,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -406,10 +410,9 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -423,11 +426,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -440,10 +442,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -457,11 +459,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -474,10 +475,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -491,11 +492,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -508,10 +508,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -525,11 +525,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -542,10 +541,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -559,11 +558,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -576,10 +574,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -593,11 +591,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -610,10 +607,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 
@@ -627,11 +624,10 @@
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR,
         typename Workspace >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, work );
 }
 
@@ -644,10 +640,10 @@
 //
 template< typename MatrixAB, typename MatrixAFB, typename MatrixB,
         typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pbrfs( const fortran_int_t n,
- const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
- return pbrfs_impl< typename value< MatrixAB >::type >::invoke( n, ab,
+inline std::ptrdiff_t pbrfs( const MatrixAB& ab, const MatrixAFB& afb,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pbrfs_impl< typename value< MatrixAB >::type >::invoke( ab,
             afb, b, x, ferr, berr, optimal_workspace() );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -117,13 +117,13 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const fortran_int_t n, MatrixAB& ab ) {
+ static std::ptrdiff_t invoke( MatrixAB& ab ) {
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbstf( uplo(), n, bandwidth(ab, uplo()),
+ return detail::pbstf( uplo(), size_column(ab), bandwidth(ab, uplo()),
                 begin_value(ab), stride_major(ab) );
     }
 
@@ -144,9 +144,8 @@
 // * MatrixAB&
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t pbstf( const fortran_int_t n, MatrixAB& ab ) {
- return pbstf_impl< typename value< MatrixAB >::type >::invoke( n,
- ab );
+inline std::ptrdiff_t pbstf( MatrixAB& ab ) {
+ return pbstf_impl< typename value< MatrixAB >::type >::invoke( ab );
 }
 
 //
@@ -154,10 +153,8 @@
 // * const MatrixAB&
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t pbstf( const fortran_int_t n,
- const MatrixAB& ab ) {
- return pbstf_impl< typename value< MatrixAB >::type >::invoke( n,
- ab );
+inline std::ptrdiff_t pbstf( const MatrixAB& ab ) {
+ return pbstf_impl< typename value< MatrixAB >::type >::invoke( ab );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -117,13 +117,13 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB >
- static std::ptrdiff_t invoke( const fortran_int_t n, MatrixAB& ab ) {
+ static std::ptrdiff_t invoke( MatrixAB& ab ) {
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- return detail::pbtrf( uplo(), n, bandwidth(ab, uplo()),
+ return detail::pbtrf( uplo(), size_column(ab), bandwidth(ab, uplo()),
                 begin_value(ab), stride_major(ab) );
     }
 
@@ -144,9 +144,8 @@
 // * MatrixAB&
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t pbtrf( const fortran_int_t n, MatrixAB& ab ) {
- return pbtrf_impl< typename value< MatrixAB >::type >::invoke( n,
- ab );
+inline std::ptrdiff_t pbtrf( MatrixAB& ab ) {
+ return pbtrf_impl< typename value< MatrixAB >::type >::invoke( ab );
 }
 
 //
@@ -154,10 +153,8 @@
 // * const MatrixAB&
 //
 template< typename MatrixAB >
-inline std::ptrdiff_t pbtrf( const fortran_int_t n,
- const MatrixAB& ab ) {
- return pbtrf_impl< typename value< MatrixAB >::type >::invoke( n,
- ab );
+inline std::ptrdiff_t pbtrf( const MatrixAB& ab ) {
+ return pbtrf_impl< typename value< MatrixAB >::type >::invoke( ab );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -117,23 +117,24 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAB& ab,
+ MatrixB& b ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ab) >= 0 );
         BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pbtrs( uplo, n, bandwidth(ab, uplo()), size_column(b),
- begin_value(ab), stride_major(ab), begin_value(b),
- stride_major(b) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::pbtrs( uplo, size_column(ab), bandwidth(ab, uplo()),
+ size_column(b), begin_value(ab), stride_major(ab),
+ begin_value(b), stride_major(b) );
     }
 
 };
@@ -153,10 +154,10 @@
 // * MatrixB&
 //
 template< typename MatrixAB, typename MatrixB >
-inline std::ptrdiff_t pbtrs( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, MatrixB& b ) {
+inline std::ptrdiff_t pbtrs( const char uplo, const MatrixAB& ab,
+ MatrixB& b ) {
     return pbtrs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, ab, b );
+ ab, b );
 }
 
 //
@@ -164,10 +165,10 @@
 // * const MatrixB&
 //
 template< typename MatrixAB, typename MatrixB >
-inline std::ptrdiff_t pbtrs( const char uplo, const fortran_int_t n,
- const MatrixAB& ab, const MatrixB& b ) {
+inline std::ptrdiff_t pbtrs( const char uplo, const MatrixAB& ab,
+ const MatrixB& b ) {
     return pbtrs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, ab, b );
+ ab, b );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -174,13 +174,13 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( size_column(a) ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 size_column(a) ));
         BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -193,7 +193,7 @@
                 size_column(a)) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column(a)) );
- return detail::porfs( uplo(), size_column(a), size_column(x),
+ return detail::porfs( uplo(), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(af),
                 stride_major(af), begin_value(b), stride_major(b),
                 begin_value(x), stride_major(x), begin_value(ferr),
@@ -296,13 +296,13 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
                 size_column(a) ));
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 size_column(a) ));
         BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -315,7 +315,7 @@
                 size_column(a)) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column(a)) );
- return detail::porfs( uplo(), size_column(a), size_column(x),
+ return detail::porfs( uplo(), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(af),
                 stride_major(af), begin_value(b), stride_major(b),
                 begin_value(x), stride_major(x), begin_value(ferr),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -174,16 +174,16 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( n ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pprfs( uplo(), n, size_column(x), begin_value(ap),
+ return detail::pprfs( uplo(), n, size_column(b), begin_value(ap),
                 begin_value(afp), begin_value(b), stride_major(b),
                 begin_value(x), stride_major(x), begin_value(ferr),
                 begin_value(berr), begin_value(work.select(real_type())),
@@ -286,15 +286,15 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         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_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pprfs( uplo(), n, size_column(x), begin_value(ap),
+ return detail::pprfs( uplo(), n, size_column(b), begin_value(ap),
                 begin_value(afp), begin_value(b), stride_major(b),
                 begin_value(x), stride_major(x), begin_value(ferr),
                 begin_value(berr), begin_value(work.select(value_type())),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -112,10 +112,10 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAP >
- static std::ptrdiff_t invoke( const fortran_int_t n, MatrixAP& ap ) {
+ static std::ptrdiff_t invoke( MatrixAP& ap ) {
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
- BOOST_ASSERT( n >= 0 );
- return detail::pptrf( uplo(), n, begin_value(ap) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::pptrf( uplo(), size_column(ap), begin_value(ap) );
     }
 
 };
@@ -135,9 +135,8 @@
 // * MatrixAP&
 //
 template< typename MatrixAP >
-inline std::ptrdiff_t pptrf( const fortran_int_t n, MatrixAP& ap ) {
- return pptrf_impl< typename value< MatrixAP >::type >::invoke( n,
- ap );
+inline std::ptrdiff_t pptrf( MatrixAP& ap ) {
+ return pptrf_impl< typename value< MatrixAP >::type >::invoke( ap );
 }
 
 //
@@ -145,10 +144,8 @@
 // * const MatrixAP&
 //
 template< typename MatrixAP >
-inline std::ptrdiff_t pptrf( const fortran_int_t n,
- const MatrixAP& ap ) {
- return pptrf_impl< typename value< MatrixAP >::type >::invoke( n,
- ap );
+inline std::ptrdiff_t pptrf( const MatrixAP& ap ) {
+ return pptrf_impl< typename value< MatrixAP >::type >::invoke( ap );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -98,9 +98,8 @@
     //
     template< typename MatrixAB, typename MatrixBB, typename MatrixX,
             typename WORK >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x, detail::workspace1<
- WORK > work ) {
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -113,18 +112,20 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
         BOOST_ASSERT( bandwidth(bb, uplo()) >= bandwidth(bb, uplo()) );
- 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(bb) == 1 || stride_minor(bb) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
         BOOST_ASSERT( stride_major(bb) >= bandwidth(bb, uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' );
- return detail::sbgst( vect, uplo(), n, bandwidth(ab, uplo()),
- bandwidth(bb, uplo()), begin_value(ab), stride_major(ab),
- begin_value(bb), stride_major(bb), begin_value(x),
- stride_major(x), begin_value(work.select(real_type())) );
+ return detail::sbgst( vect, uplo(), size_column(ab), bandwidth(ab,
+ uplo()), bandwidth(bb, uplo()), begin_value(ab),
+ stride_major(ab), begin_value(bb), stride_major(bb),
+ begin_value(x), stride_major(x),
+ begin_value(work.select(real_type())) );
     }
 
     //
@@ -135,11 +136,11 @@
     // * Enables the unblocked algorithm (BLAS level 2)
     //
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x,
- minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( vect, n, ab, bb, x, workspace( tmp_work ) );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
+ return invoke( vect, ab, bb, x, workspace( tmp_work ) );
     }
 
     //
@@ -150,10 +151,9 @@
     // * Enables the blocked algorithm (BLAS level 3)
     //
     template< typename MatrixAB, typename MatrixBB, typename MatrixX >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x,
- optimal_workspace work ) {
- return invoke( vect, n, ab, bb, x, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, optimal_workspace work ) {
+ return invoke( vect, ab, bb, x, minimal_workspace() );
     }
 
     //
@@ -183,10 +183,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x, Workspace work ) {
+inline std::ptrdiff_t sbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, Workspace work ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -196,10 +196,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, MatrixX& x ) {
+inline std::ptrdiff_t sbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 //
@@ -210,10 +210,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, MatrixX& x, Workspace work ) {
+inline std::ptrdiff_t sbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x, Workspace work ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -223,10 +223,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, MatrixX& x ) {
+inline std::ptrdiff_t sbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, MatrixX& x ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 //
@@ -237,10 +237,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, const MatrixX& x, Workspace work ) {
+inline std::ptrdiff_t sbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x, Workspace work ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -250,10 +250,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- MatrixAB& ab, const MatrixBB& bb, const MatrixX& x ) {
+inline std::ptrdiff_t sbgst( const char vect, MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 //
@@ -264,11 +264,10 @@
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX,
         typename Workspace >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, const MatrixX& x,
- Workspace work ) {
+inline std::ptrdiff_t sbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x, Workspace work ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, work );
+ ab, bb, x, work );
 }
 
 //
@@ -278,10 +277,10 @@
 // * Default workspace-type (optimal)
 //
 template< typename MatrixAB, typename MatrixBB, typename MatrixX >
-inline std::ptrdiff_t sbgst( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const MatrixBB& bb, const MatrixX& x ) {
+inline std::ptrdiff_t sbgst( const char vect, const MatrixAB& ab,
+ const MatrixBB& bb, const MatrixX& x ) {
     return sbgst_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, bb, x, optimal_workspace() );
+ ab, bb, x, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -97,9 +97,8 @@
     //
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ, typename WORK >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
                 typename remove_const< typename value<
@@ -117,15 +116,16 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
         BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(d) >= n );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(d) >= size_column(ab) );
+ 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(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( stride_major(ab) >= bandwidth(ab, uplo())+1 );
         BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' );
- return detail::sbtrd( vect, uplo(), n, bandwidth(ab, uplo()),
- begin_value(ab), stride_major(ab), begin_value(d),
+ return detail::sbtrd( vect, uplo(), size_column(ab), bandwidth(ab,
+ uplo()), begin_value(ab), stride_major(ab), begin_value(d),
                 begin_value(e), begin_value(q), stride_major(q),
                 begin_value(work.select(real_type())) );
     }
@@ -139,11 +139,11 @@
     //
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( vect, n, ab, d, e, q, workspace( tmp_work ) );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
+ return invoke( vect, ab, d, e, q, workspace( tmp_work ) );
     }
 
     //
@@ -155,10 +155,9 @@
     //
     template< typename MatrixAB, typename VectorD, typename VectorE,
             typename MatrixQ >
- static std::ptrdiff_t invoke( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- optimal_workspace work ) {
- return invoke( vect, n, ab, d, e, q, minimal_workspace() );
+ static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, optimal_workspace work ) {
+ return invoke( vect, ab, d, e, q, minimal_workspace() );
     }
 
     //
@@ -190,10 +189,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -206,10 +205,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -222,11 +221,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -239,10 +237,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -255,11 +253,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -272,10 +269,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -288,11 +285,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -305,10 +301,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -321,11 +317,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -338,10 +333,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -354,11 +349,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -371,10 +365,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -387,11 +381,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -404,10 +397,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -420,11 +413,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -437,10 +429,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e, MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -453,11 +445,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, const MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -470,10 +461,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -486,11 +477,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, const MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -503,10 +493,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -519,11 +509,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -536,10 +525,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -552,11 +541,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -569,10 +557,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -585,11 +573,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, const MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -602,10 +589,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab, VectorD& d,
+ const VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -618,11 +605,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q,
- Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, const MatrixQ& q, Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -635,10 +621,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, VectorD& d, const VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ VectorD& d, const VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -651,11 +637,11 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, const MatrixQ& q,
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q,
         Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -668,10 +654,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- MatrixAB& ab, const VectorD& d, const VectorE& e, const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 //
@@ -684,11 +670,11 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ, typename Workspace >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e,
- const MatrixQ& q, Workspace work ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q,
+ Workspace work ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, work );
+ ab, d, e, q, work );
 }
 
 //
@@ -701,11 +687,10 @@
 //
 template< typename MatrixAB, typename VectorD, typename VectorE,
         typename MatrixQ >
-inline std::ptrdiff_t sbtrd( const char vect, const fortran_int_t n,
- const MatrixAB& ab, const VectorD& d, const VectorE& e,
- const MatrixQ& q ) {
+inline std::ptrdiff_t sbtrd( const char vect, const MatrixAB& ab,
+ const VectorD& d, const VectorE& e, const MatrixQ& q ) {
     return sbtrd_impl< typename value< MatrixAB >::type >::invoke( vect,
- n, ab, d, e, q, optimal_workspace() );
+ ab, d, e, q, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -174,17 +174,17 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= n );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( n ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sprfs( uplo(), n, size_column(x), begin_value(ap),
+ return detail::sprfs( uplo(), n, size_column(b), begin_value(ap),
                 begin_value(afp), begin_value(ipiv), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),
                 begin_value(ferr), begin_value(berr),
@@ -291,16 +291,16 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= n );
         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_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sprfs( uplo(), n, size_column(x), begin_value(ap),
+ return detail::sprfs( uplo(), n, size_column(b), begin_value(ap),
                 begin_value(afp), begin_value(ipiv), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),
                 begin_value(ferr), begin_value(berr),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -114,12 +114,12 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAP, typename VectorIPIV >
- static std::ptrdiff_t invoke( const fortran_int_t n, MatrixAP& ap,
- VectorIPIV& ipiv ) {
+ static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv ) {
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
- BOOST_ASSERT( n >= 0 );
- return detail::sptrf( uplo(), n, begin_value(ap), begin_value(ipiv) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::sptrf( uplo(), size_column(ap), begin_value(ap),
+ begin_value(ipiv) );
     }
 
 };
@@ -140,9 +140,8 @@
 // * VectorIPIV&
 //
 template< typename MatrixAP, typename VectorIPIV >
-inline std::ptrdiff_t sptrf( const fortran_int_t n, MatrixAP& ap,
- VectorIPIV& ipiv ) {
- return sptrf_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sptrf( MatrixAP& ap, VectorIPIV& ipiv ) {
+ return sptrf_impl< typename value< MatrixAP >::type >::invoke( ap,
             ipiv );
 }
 
@@ -152,9 +151,8 @@
 // * VectorIPIV&
 //
 template< typename MatrixAP, typename VectorIPIV >
-inline std::ptrdiff_t sptrf( const fortran_int_t n,
- const MatrixAP& ap, VectorIPIV& ipiv ) {
- return sptrf_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sptrf( const MatrixAP& ap, VectorIPIV& ipiv ) {
+ return sptrf_impl< typename value< MatrixAP >::type >::invoke( ap,
             ipiv );
 }
 
@@ -164,9 +162,8 @@
 // * const VectorIPIV&
 //
 template< typename MatrixAP, typename VectorIPIV >
-inline std::ptrdiff_t sptrf( const fortran_int_t n, MatrixAP& ap,
- const VectorIPIV& ipiv ) {
- return sptrf_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sptrf( MatrixAP& ap, const VectorIPIV& ipiv ) {
+ return sptrf_impl< typename value< MatrixAP >::type >::invoke( ap,
             ipiv );
 }
 
@@ -176,9 +173,8 @@
 // * const VectorIPIV&
 //
 template< typename MatrixAP, typename VectorIPIV >
-inline std::ptrdiff_t sptrf( const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv ) {
- return sptrf_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sptrf( const MatrixAP& ap, const VectorIPIV& ipiv ) {
+ return sptrf_impl< typename value< MatrixAP >::type >::invoke( ap,
             ipiv );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sygst.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -92,20 +92,22 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixA, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t itype,
- const fortran_int_t n, MatrixA& a, const MatrixB& b ) {
+ static std::ptrdiff_t invoke( const fortran_int_t itype, MatrixA& a,
+ const MatrixB& b ) {
         typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
                 MatrixB >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sygst( itype, uplo(), n, begin_value(a),
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::sygst( itype, uplo(), size_column(a), begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b) );
     }
 
@@ -126,10 +128,10 @@
 // * MatrixA&
 //
 template< typename MatrixA, typename MatrixB >
-inline std::ptrdiff_t sygst( const fortran_int_t itype,
- const fortran_int_t n, MatrixA& a, const MatrixB& b ) {
+inline std::ptrdiff_t sygst( const fortran_int_t itype, MatrixA& a,
+ const MatrixB& b ) {
     return sygst_impl< typename value< MatrixA >::type >::invoke( itype,
- n, a, b );
+ a, b );
 }
 
 //
@@ -138,9 +140,9 @@
 //
 template< typename MatrixA, typename MatrixB >
 inline std::ptrdiff_t sygst( const fortran_int_t itype,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b ) {
+ const MatrixA& a, const MatrixB& b ) {
     return sygst_impl< typename value< MatrixA >::type >::invoke( itype,
- n, a, b );
+ a, b );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -177,14 +177,14 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= size_column(a) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( size_column(a) ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 size_column(a) ));
         BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -197,7 +197,7 @@
                 size_column(a)) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column(a)) );
- return detail::syrfs( uplo(), size_column(a), size_column(x),
+ return detail::syrfs( uplo(), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(af),
                 stride_major(af), begin_value(ipiv), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),
@@ -304,14 +304,14 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(ipiv) >= size_column(a) );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
                 size_column(a) ));
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 size_column(a) ));
         BOOST_ASSERT( size_column(a) >= 0 );
- BOOST_ASSERT( size_column(x) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(af) == 1 || stride_minor(af) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
@@ -324,7 +324,7 @@
                 size_column(a)) );
         BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
                 size_column(a)) );
- return detail::syrfs( uplo(), size_column(a), size_column(x),
+ return detail::syrfs( uplo(), size_column(a), size_column(b),
                 begin_value(a), stride_major(a), begin_value(af),
                 stride_major(af), begin_value(ipiv), begin_value(b),
                 stride_major(b), begin_value(x), stride_major(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -140,20 +140,20 @@
     //
     template< typename MatrixAB, typename WORK, typename IWORK >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK,
- IWORK > work ) {
+ const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
+ detail::workspace2< WORK, IWORK > work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         BOOST_ASSERT( kd >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ min_size_iwork( size_column(ab) ));
+ 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( stride_major(ab) >= kd+1 );
- return detail::tbcon( norm, uplo, diag(), n, kd, begin_value(ab),
- stride_major(ab), rcond,
+ return detail::tbcon( norm, uplo, diag(), size_column(ab), kd,
+ begin_value(ab), stride_major(ab), rcond,
                 begin_value(work.select(real_type())),
                 begin_value(work.select(fortran_int_t())) );
     }
@@ -167,13 +167,14 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, real_type& rcond, minimal_workspace work ) {
+ const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
+ minimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( norm, uplo, n, kd, ab, rcond, workspace( tmp_work,
+ min_size_iwork( size_column(ab) ) );
+ return invoke( norm, uplo, kd, ab, rcond, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
@@ -186,10 +187,10 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, real_type& rcond, optimal_workspace work ) {
+ const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
+ optimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( norm, uplo, n, kd, ab, rcond, minimal_workspace() );
+ return invoke( norm, uplo, kd, ab, rcond, minimal_workspace() );
     }
 
     //
@@ -226,19 +227,20 @@
     //
     template< typename MatrixAB, typename WORK, typename RWORK >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK,
- RWORK > work ) {
+ const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
+ detail::workspace2< WORK, RWORK > work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         BOOST_ASSERT( kd >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
- 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( stride_major(ab) >= kd+1 );
- return detail::tbcon( norm, uplo, diag(), n, kd, begin_value(ab),
- stride_major(ab), rcond,
+ return detail::tbcon( norm, uplo, diag(), size_column(ab), kd,
+ begin_value(ab), stride_major(ab), rcond,
                 begin_value(work.select(value_type())),
                 begin_value(work.select(real_type())) );
     }
@@ -252,12 +254,14 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, real_type& rcond, minimal_workspace work ) {
+ const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
+ minimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( norm, uplo, n, kd, ab, rcond, workspace( tmp_work,
+ 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( norm, uplo, kd, ab, rcond, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -270,10 +274,10 @@
     //
     template< typename MatrixAB >
     static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, real_type& rcond, optimal_workspace work ) {
+ const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
+ optimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( norm, uplo, n, kd, ab, rcond, minimal_workspace() );
+ return invoke( norm, uplo, kd, ab, rcond, minimal_workspace() );
     }
 
     //
@@ -309,11 +313,11 @@
 //
 template< typename MatrixAB, typename Workspace >
 inline std::ptrdiff_t tbcon( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, typename remove_imaginary< typename value<
+ const fortran_int_t kd, const MatrixAB& ab,
+ typename remove_imaginary< typename value<
         MatrixAB >::type >::type& rcond, Workspace work ) {
     return tbcon_impl< typename value< MatrixAB >::type >::invoke( norm,
- uplo, n, kd, ab, rcond, work );
+ uplo, kd, ab, rcond, work );
 }
 
 //
@@ -322,11 +326,11 @@
 //
 template< typename MatrixAB >
 inline std::ptrdiff_t tbcon( const char norm, const char uplo,
- const fortran_int_t n, const fortran_int_t kd,
- const MatrixAB& ab, typename remove_imaginary< typename value<
+ const fortran_int_t kd, const MatrixAB& ab,
+ typename remove_imaginary< typename value<
         MatrixAB >::type >::type& rcond ) {
     return tbcon_impl< typename value< MatrixAB >::type >::invoke( norm,
- uplo, n, kd, ab, rcond, optimal_workspace() );
+ uplo, kd, ab, rcond, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -156,10 +156,10 @@
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename IWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ IWORK > work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixAB >::type >::type,
@@ -180,22 +180,25 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( kd >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
- BOOST_ASSERT( size_column(x) >= 0 );
+ min_size_iwork( size_column(ab) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ab) ));
+ BOOST_ASSERT( size_column(ab) >= 0 );
+ BOOST_ASSERT( size_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(ab) >= kd+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tbrfs( uplo, trans(), diag(), n, kd, size_column(x),
- begin_value(ab), stride_major(ab), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::tbrfs( uplo, trans(), diag(), size_column(ab), kd,
+ size_column(b), begin_value(ab), stride_major(ab),
+ begin_value(b), stride_major(b), begin_value(x),
+ stride_major(x), begin_value(ferr), begin_value(berr),
                 begin_value(work.select(real_type())),
                 begin_value(work.select(fortran_int_t())) );
     }
@@ -209,15 +212,15 @@
     //
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ab) ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( uplo, n, kd, ab, b, x, ferr, berr, workspace( tmp_work,
+ min_size_iwork( size_column(ab) ) );
+ return invoke( uplo, kd, ab, b, x, ferr, berr, workspace( tmp_work,
                 tmp_iwork ) );
     }
 
@@ -230,13 +233,11 @@
     //
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( uplo, n, kd, ab, b, x, ferr, berr,
- minimal_workspace() );
+ return invoke( uplo, kd, ab, b, x, ferr, berr, minimal_workspace() );
     }
 
     //
@@ -274,10 +275,10 @@
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR, typename WORK,
             typename RWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ RWORK > work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< VectorFERR >::type >::type,
@@ -294,21 +295,25 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
         BOOST_ASSERT( kd >= 0 );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(berr) >= size_column(x) );
- 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_column(x) >= 0 );
+ BOOST_ASSERT( size(berr) >= size_column(b) );
+ 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_column(b) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
         BOOST_ASSERT( stride_major(ab) >= kd+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tbrfs( uplo, trans(), diag(), n, kd, size_column(x),
- begin_value(ab), stride_major(ab), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ab)) );
+ return detail::tbrfs( uplo, trans(), diag(), size_column(ab), kd,
+ size_column(b), begin_value(ab), stride_major(ab),
+ begin_value(b), stride_major(b), begin_value(x),
+ stride_major(x), begin_value(ferr), begin_value(berr),
                 begin_value(work.select(value_type())),
                 begin_value(work.select(real_type())) );
     }
@@ -322,14 +327,15 @@
     //
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( uplo, n, kd, ab, b, x, ferr, berr, workspace( tmp_work,
+ 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( uplo, kd, ab, b, x, ferr, berr, workspace( tmp_work,
                 tmp_rwork ) );
     }
 
@@ -342,13 +348,11 @@
     //
     template< typename MatrixAB, typename MatrixB, typename MatrixX,
             typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( uplo, n, kd, ab, b, x, ferr, berr,
- minimal_workspace() );
+ return invoke( uplo, kd, ab, b, x, ferr, berr, minimal_workspace() );
     }
 
     //
@@ -386,12 +390,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, work );
+ kd, ab, b, x, ferr, berr, work );
 }
 
 //
@@ -402,11 +405,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, optimal_workspace() );
+ kd, ab, b, x, ferr, berr, optimal_workspace() );
 }
 
 //
@@ -417,12 +420,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, work );
+ kd, ab, b, x, ferr, berr, work );
 }
 
 //
@@ -433,11 +435,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, optimal_workspace() );
+ kd, ab, b, x, ferr, berr, optimal_workspace() );
 }
 
 //
@@ -448,12 +450,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, work );
+ kd, ab, b, x, ferr, berr, work );
 }
 
 //
@@ -464,11 +465,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, optimal_workspace() );
+ kd, ab, b, x, ferr, berr, optimal_workspace() );
 }
 
 //
@@ -479,12 +480,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, work );
+ kd, ab, b, x, ferr, berr, work );
 }
 
 //
@@ -495,11 +495,11 @@
 //
 template< typename MatrixAB, typename MatrixB, typename MatrixX,
         typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
     return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b, x, ferr, berr, optimal_workspace() );
+ kd, ab, b, x, ferr, berr, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -131,8 +131,8 @@
     // * Asserts that most arguments make sense.
     //
     template< typename MatrixAB, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, MatrixB& b ) {
         typedef typename result_of::trans_tag< MatrixAB, order >::type trans;
         typedef typename result_of::diag_tag< MatrixAB >::type diag;
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -141,15 +141,16 @@
                 MatrixB >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_ASSERT( kd >= 0 );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size_column(b) >= 0 );
+ BOOST_ASSERT( size_column_op(ab, trans()) >= 0 );
         BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( stride_major(ab) >= kd+1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tbtrs( uplo, trans(), diag(), n, kd, size_column(b),
- begin_value(ab), stride_major(ab), begin_value(b),
- stride_major(b) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column_op(ab, trans())) );
+ return detail::tbtrs( uplo, trans(), diag(), size_column_op(ab,
+ trans()), kd, size_column(b), begin_value(ab),
+ stride_major(ab), begin_value(b), stride_major(b) );
     }
 
 };
@@ -169,10 +170,10 @@
 // * MatrixB&
 //
 template< typename MatrixAB, typename MatrixB >
-inline std::ptrdiff_t tbtrs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, MatrixB& b ) {
+inline std::ptrdiff_t tbtrs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, MatrixB& b ) {
     return tbtrs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b );
+ kd, ab, b );
 }
 
 //
@@ -180,10 +181,10 @@
 // * const MatrixB&
 //
 template< typename MatrixAB, typename MatrixB >
-inline std::ptrdiff_t tbtrs( const char uplo, const fortran_int_t n,
- const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b ) {
+inline std::ptrdiff_t tbtrs( const char uplo, const fortran_int_t kd,
+ const MatrixAB& ab, const MatrixB& b ) {
     return tbtrs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- n, kd, ab, b );
+ kd, ab, b );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -146,10 +146,9 @@
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR, typename WORK >
     static std::ptrdiff_t invoke( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m,
- detail::workspace1< WORK > work ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, detail::workspace1< WORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixS >::type >::type,
                 typename remove_const< typename value<
@@ -166,19 +165,22 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
         BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
         BOOST_ASSERT( mm >= m );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(s) ));
+ BOOST_ASSERT( size_column(s) >= 0 );
         BOOST_ASSERT( size_minor(p) == 1 || stride_minor(p) == 1 );
         BOOST_ASSERT( size_minor(s) == 1 || stride_minor(s) == 1 );
         BOOST_ASSERT( size_minor(vl) == 1 || stride_minor(vl) == 1 );
         BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 1 );
- BOOST_ASSERT( stride_major(p) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(s) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgevc( side, howmny, begin_value(select), n,
- begin_value(s), stride_major(s), begin_value(p),
- stride_major(p), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), mm, m,
+ BOOST_ASSERT( stride_major(p) >= std::max< std::ptrdiff_t >(1,
+ size_column(s)) );
+ BOOST_ASSERT( stride_major(s) >= std::max< std::ptrdiff_t >(1,
+ size_column(s)) );
+ return detail::tgevc( side, howmny, begin_value(select),
+ size_column(s), begin_value(s), stride_major(s),
+ begin_value(p), stride_major(p), begin_value(vl),
+ stride_major(vl), begin_value(vr), stride_major(vr), mm, m,
                 begin_value(work.select(real_type())) );
     }
 
@@ -192,12 +194,12 @@
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
     static std::ptrdiff_t invoke( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m,
- minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( side, howmny, select, n, s, p, vl, vr, mm, m,
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(s) ) );
+ return invoke( side, howmny, select, s, p, vl, vr, mm, m,
                 workspace( tmp_work ) );
     }
 
@@ -211,11 +213,10 @@
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
     static std::ptrdiff_t invoke( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m,
- optimal_workspace work ) {
- return invoke( side, howmny, select, n, s, p, vl, vr, mm, m,
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, optimal_workspace work ) {
+ return invoke( side, howmny, select, s, p, vl, vr, mm, m,
                 minimal_workspace() );
     }
 
@@ -247,10 +248,9 @@
             typename MatrixVL, typename MatrixVR, typename WORK,
             typename RWORK >
     static std::ptrdiff_t invoke( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m,
- detail::workspace2< WORK, RWORK > work ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, detail::workspace2< WORK, RWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixS >::type >::type,
                 typename remove_const< typename value<
@@ -267,20 +267,24 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixVR >::value) );
         BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' );
         BOOST_ASSERT( mm >= m );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
- 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(s) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(s) ));
+ BOOST_ASSERT( size_column(s) >= 0 );
         BOOST_ASSERT( size_minor(p) == 1 || stride_minor(p) == 1 );
         BOOST_ASSERT( size_minor(s) == 1 || stride_minor(s) == 1 );
         BOOST_ASSERT( size_minor(vl) == 1 || stride_minor(vl) == 1 );
         BOOST_ASSERT( size_minor(vr) == 1 || stride_minor(vr) == 1 );
- BOOST_ASSERT( stride_major(p) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(s) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgevc( side, howmny, begin_value(select), n,
- begin_value(s), stride_major(s), begin_value(p),
- stride_major(p), begin_value(vl), stride_major(vl),
- begin_value(vr), stride_major(vr), mm, m,
+ BOOST_ASSERT( stride_major(p) >= std::max< std::ptrdiff_t >(1,
+ size_column(s)) );
+ BOOST_ASSERT( stride_major(s) >= std::max< std::ptrdiff_t >(1,
+ size_column(s)) );
+ return detail::tgevc( side, howmny, begin_value(select),
+ size_column(s), begin_value(s), stride_major(s),
+ begin_value(p), stride_major(p), begin_value(vl),
+ stride_major(vl), begin_value(vr), stride_major(vr), mm, m,
                 begin_value(work.select(value_type())),
                 begin_value(work.select(real_type())) );
     }
@@ -295,13 +299,14 @@
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
     static std::ptrdiff_t invoke( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( side, howmny, select, n, s, p, vl, vr, mm, m,
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(s) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(s) ) );
+ return invoke( side, howmny, select, s, p, vl, vr, mm, m,
                 workspace( tmp_work, tmp_rwork ) );
     }
 
@@ -315,11 +320,10 @@
     template< typename VectorSELECT, typename MatrixS, typename MatrixP,
             typename MatrixVL, typename MatrixVR >
     static std::ptrdiff_t invoke( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m,
- optimal_workspace work ) {
- return invoke( side, howmny, select, n, s, p, vl, vr, mm, m,
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, optimal_workspace work ) {
+ return invoke( side, howmny, select, s, p, vl, vr, mm, m,
                 minimal_workspace() );
     }
 
@@ -359,11 +363,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR, typename Workspace >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m, Workspace work ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, Workspace work ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, work );
+ howmny, select, s, p, vl, vr, mm, m, work );
 }
 
 //
@@ -375,11 +379,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, optimal_workspace() );
+ howmny, select, s, p, vl, vr, mm, m, optimal_workspace() );
 }
 
 //
@@ -391,11 +395,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR, typename Workspace >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, const MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m, Workspace work ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ const MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, Workspace work ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, work );
+ howmny, select, s, p, vl, vr, mm, m, work );
 }
 
 //
@@ -407,11 +411,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, const MatrixVL& vl, MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ const MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, optimal_workspace() );
+ howmny, select, s, p, vl, vr, mm, m, optimal_workspace() );
 }
 
 //
@@ -423,11 +427,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR, typename Workspace >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, const MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m, Workspace work ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, const MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, Workspace work ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, work );
+ howmny, select, s, p, vl, vr, mm, m, work );
 }
 
 //
@@ -439,11 +443,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, MatrixVL& vl, const MatrixVR& vr,
- const fortran_int_t mm, fortran_int_t& m ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ MatrixVL& vl, const MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, optimal_workspace() );
+ howmny, select, s, p, vl, vr, mm, m, optimal_workspace() );
 }
 
 //
@@ -455,12 +459,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR, typename Workspace >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, const MatrixVL& vl,
- const MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m,
- Workspace work ) {
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ const MatrixVL& vl, const MatrixVR& vr, const fortran_int_t mm,
+ fortran_int_t& m, Workspace work ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, work );
+ howmny, select, s, p, vl, vr, mm, m, work );
 }
 
 //
@@ -472,12 +475,11 @@
 template< typename VectorSELECT, typename MatrixS, typename MatrixP,
         typename MatrixVL, typename MatrixVR >
 inline std::ptrdiff_t tgevc( const char side, const char howmny,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixS& s, const MatrixP& p, const MatrixVL& vl,
- const MatrixVR& vr, const fortran_int_t mm,
+ const VectorSELECT& select, const MatrixS& s, const MatrixP& p,
+ const MatrixVL& vl, const MatrixVR& vr, const fortran_int_t mm,
         fortran_int_t& m ) {
     return tgevc_impl< typename value< MatrixS >::type >::invoke( side,
- howmny, select, n, s, p, vl, vr, mm, m, optimal_workspace() );
+ howmny, select, s, p, vl, vr, mm, m, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -143,8 +143,8 @@
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
     static std::ptrdiff_t invoke( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -161,16 +161,18 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( n >= 0 );
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgexc( wantq, wantz, n, begin_value(a),
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::tgexc( wantq, wantz, size_column(a), begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b),
                 begin_value(q), stride_major(q), begin_value(z),
                 stride_major(z), ifst, ilst,
@@ -198,8 +200,8 @@
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ, $WORKSPACE_TYPENAMES >
     static std::ptrdiff_t invoke( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
             detail::workspace$WORKSPACE_SIZE< $WORKSPACE_TYPES > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -217,14 +219,16 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgexc( wantq, wantz, n, begin_value(a),
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::tgexc( wantq, wantz, size_column(a), begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b),
                 begin_value(q), stride_major(q), begin_value(z),
                 stride_major(z), ifst, ilst );
@@ -240,11 +244,11 @@
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
     static std::ptrdiff_t invoke( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
             minimal_workspace work ) {
 $SETUP_MIN_WORKARRAYS_POST
- return invoke( wantq, wantz, n, a, b, q, z, ifst, ilst,
+ return invoke( wantq, wantz, a, b, q, z, ifst, ilst,
                 workspace( $TMP_WORKARRAYS ) );
     }
 
@@ -258,8 +262,8 @@
     template< typename MatrixA, typename MatrixB, typename MatrixQ,
             typename MatrixZ >
     static std::ptrdiff_t invoke( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
             optimal_workspace work ) {
 $OPT_WORKSPACE_FUNC
     }
@@ -287,10 +291,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -303,10 +307,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -319,10 +323,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b, MatrixQ& q,
- MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -335,11 +339,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- MatrixQ& q, MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -352,10 +355,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -368,11 +371,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b,
- const MatrixQ& q, MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -385,11 +387,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b,
- const MatrixQ& q, MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -402,11 +403,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- const MatrixQ& q, MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -419,10 +419,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -435,10 +435,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -451,10 +451,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -467,11 +467,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- MatrixQ& q, const MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -484,10 +483,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -500,11 +499,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -517,11 +515,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 
 //
@@ -534,11 +531,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, fortran_int_t& ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, const MatrixQ& q,
+ const MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst );
+ wantz, a, b, q, z, ifst, ilst );
 }
 //
 // Overloaded function for tgexc. Its overload differs for
@@ -551,11 +547,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
         Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -569,10 +565,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -586,11 +582,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ const MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
         Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -604,10 +600,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -621,11 +617,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
         Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -639,10 +635,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b, MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -656,11 +652,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ const MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -674,11 +670,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -692,11 +687,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, const MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst,
+ MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
         Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -710,10 +705,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, const MatrixQ& q,
- MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -727,11 +722,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b,
- const MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ const MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -745,11 +740,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b,
- const MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -763,11 +757,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b,
- const MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -781,11 +775,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b,
- const MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -799,11 +792,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- const MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ const MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -817,11 +810,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- const MatrixQ& q, MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, const MatrixQ& q, MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -835,11 +827,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -853,11 +845,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -871,11 +862,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b, MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ const MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -889,11 +880,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b, MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -907,11 +897,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b, MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -925,11 +915,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b, MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -943,11 +932,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ const MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -961,11 +950,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, const MatrixB& b, MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -979,11 +967,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, const MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -997,11 +985,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, MatrixB& b, const MatrixQ& q,
- const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -1015,11 +1002,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ const MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -1033,11 +1020,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ const MatrixA& a, MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -1051,11 +1037,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst, Workspace work ) {
+ MatrixA& a, const MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst,
+ Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -1069,11 +1055,10 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, MatrixA& a, const MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
- fortran_int_t& ilst ) {
+ MatrixA& a, const MatrixB& b, const MatrixQ& q, const MatrixZ& z,
+ const fortran_int_t ifst, fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 //
@@ -1087,11 +1072,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ, typename Workspace >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
+ const MatrixA& a, const MatrixB& b, const MatrixQ& q,
+ const MatrixZ& z, const fortran_int_t ifst,
         fortran_int_t& ilst, Workspace work ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, work );
+ wantz, a, b, q, z, ifst, ilst, work );
 }
 
 //
@@ -1105,11 +1090,11 @@
 template< typename MatrixA, typename MatrixB, typename MatrixQ,
         typename MatrixZ >
 inline std::ptrdiff_t tgexc( const logical_t wantq, const logical_t wantz,
- const fortran_int_t n, const MatrixA& a, const MatrixB& b,
- const MatrixQ& q, const MatrixZ& z, const fortran_int_t ifst,
+ const MatrixA& a, const MatrixB& b, const MatrixQ& q,
+ const MatrixZ& z, const fortran_int_t ifst,
         fortran_int_t& ilst ) {
     return tgexc_impl< typename value< MatrixA >::type >::invoke( wantq,
- wantz, n, a, b, q, z, ifst, ilst, optimal_workspace() );
+ wantz, a, b, q, z, ifst, ilst, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp 2010-01-12 11:28:33 EST (Tue, 12 Jan 2010)
@@ -162,11 +162,11 @@
             typename WORK, typename IWORK >
     static std::ptrdiff_t invoke( const fortran_int_t ijob,
             const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
- real_type& pl, real_type& pr, VectorDIF& dif, detail::workspace2<
- WORK, IWORK > work ) {
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl,
+ real_type& pr, VectorDIF& dif, detail::workspace2< WORK,
+ IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
                 typename remove_const< typename value<
@@ -203,26 +203,28 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorDIF >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(alphai) >= n );
- BOOST_ASSERT( size(alphar) >= n );
- BOOST_ASSERT( size(select) >= n );
+ BOOST_ASSERT( size(alphai) >= size_column(a) );
+ BOOST_ASSERT( size(alphar) >= size_column(a) );
+ BOOST_ASSERT( size(select) >= size_column(a) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
         BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgsen( ijob, wantq, wantz, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alphar), begin_value(alphai),
- begin_value(beta), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z), m, pl, pr, begin_value(dif),
- begin_value(work.select(real_type())),
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::tgsen( ijob, wantq, wantz, begin_value(select),
+ size_column(a), begin_value(a), stride_major(a),
+ begin_value(b), stride_major(b), begin_value(alphar),
+ begin_value(alphai), begin_value(beta), begin_value(q),
+ stride_major(q), begin_value(z), stride_major(z), m, pl, pr,
+ begin_value(dif), begin_value(work.select(real_type())),
                 size(work.select(real_type())),
                 begin_value(work.select(fortran_int_t())),
                 size(work.select(fortran_int_t())) );
@@ -240,17 +242,16 @@
             typename MatrixQ, typename MatrixZ, typename VectorDIF >
     static std::ptrdiff_t invoke( const fortran_int_t ijob,
             const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
- real_type& pl, real_type& pr, VectorDIF& dif,
- minimal_workspace work ) {
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl,
+ real_type& pr, VectorDIF& dif, minimal_workspace work ) {
         bindings::detail::array< real_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 min_size_iwork( $CALL_MIN_SIZE ) );
- return invoke( ijob, wantq, wantz, select, n, a, b, alphar, alphai,
- beta, q, z, m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
+ return invoke( ijob, wantq, wantz, select, a, b, alphar, alphai, beta,
+ q, z, m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -265,25 +266,24 @@
             typename MatrixQ, typename MatrixZ, typename VectorDIF >
     static std::ptrdiff_t invoke( const fortran_int_t ijob,
             const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
- real_type& pl, real_type& pr, VectorDIF& dif,
- optimal_workspace work ) {
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl,
+ real_type& pr, VectorDIF& dif, optimal_workspace work ) {
         real_type opt_size_work;
         fortran_int_t opt_size_iwork;
- detail::tgsen( ijob, wantq, wantz, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alphar), begin_value(alphai),
- begin_value(beta), begin_value(q), stride_major(q),
- begin_value(z), stride_major(z), m, pl, pr, begin_value(dif),
- &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::tgsen( ijob, wantq, wantz, begin_value(select),
+ size_column(a), begin_value(a), stride_major(a),
+ begin_value(b), stride_major(b), begin_value(alphar),
+ begin_value(alphai), begin_value(beta), begin_value(q),
+ stride_major(q), begin_value(z), stride_major(z), m, pl, pr,
+ begin_value(dif), &opt_size_work, -1, &opt_size_iwork, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 opt_size_iwork );
- return invoke( ijob, wantq, wantz, select, n, a, b, alphar, alphai,
- beta, q, z, m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
+ return invoke( ijob, wantq, wantz, select, a, b, alphar, alphai, beta,
+ q, z, m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -324,9 +324,9 @@
             typename IWORK >
     static std::ptrdiff_t invoke( const fortran_int_t ijob,
             const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, real_type& pl, real_type& pr,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, real_type& pl, real_type& pr,
             VectorDIF& dif, detail::workspace2< WORK, IWORK > work ) {
         BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
                 typename value< MatrixA >::type >::type,
@@ -355,24 +355,26 @@
         BOOST_STATIC_ASSERT( (is_mutable< MatrixQ >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorDIF >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(alpha) >= n );
- BOOST_ASSERT( size(select) >= n );
+ BOOST_ASSERT( size(alpha) >= size_column(a) );
+ BOOST_ASSERT( size(select) >= size_column(a) );
         BOOST_ASSERT( size(work.select(fortran_int_t())) >=
                 min_size_iwork( $CALL_MIN_SIZE ));
         BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
                 $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(a) >= 0 );
         BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
         BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
         BOOST_ASSERT( size_minor(q) == 1 || stride_minor(q) == 1 );
         BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tgsen( ijob, wantq, wantz, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alpha), begin_value(beta),
- begin_value(q), stride_major(q), begin_value(z),
- stride_major(z), m, pl, pr, begin_value(dif),
+ BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(a)) );
+ return detail::tgsen( ijob, wantq, wantz, begin_value(select),
+ size_column(a), begin_value(a), stride_major(a),
+ begin_value(b), stride_major(b), begin_value(alpha),
+ begin_value(beta), begin_value(q), stride_major(q),
+ begin_value(z), stride_major(z), m, pl, pr, begin_value(dif),
                 begin_value(work.select(value_type())),
                 size(work.select(value_type())),
                 begin_value(work.select(fortran_int_t())),
@@ -391,16 +393,16 @@
             typename MatrixZ, typename VectorDIF >
     static std::ptrdiff_t invoke( const fortran_int_t ijob,
             const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, real_type& pl, real_type& pr,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, real_type& pl, real_type& pr,
             VectorDIF& dif, minimal_workspace work ) {
         bindings::detail::array< value_type > tmp_work( min_size_work(
                 $CALL_MIN_SIZE ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 min_size_iwork( $CALL_MIN_SIZE ) );
- return invoke( ijob, wantq, wantz, select, n, a, b, alpha, beta, q, z,
- m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
+ return invoke( ijob, wantq, wantz, select, a, b, alpha, beta, q, z, m,
+ pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -415,24 +417,24 @@
             typename MatrixZ, typename VectorDIF >
     static std::ptrdiff_t invoke( const fortran_int_t ijob,
             const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, real_type& pl, real_type& pr,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, real_type& pl, real_type& pr,
             VectorDIF& dif, optimal_workspace work ) {
         value_type opt_size_work;
         fortran_int_t opt_size_iwork;
- detail::tgsen( ijob, wantq, wantz, begin_value(select), n,
- begin_value(a), stride_major(a), begin_value(b),
- stride_major(b), begin_value(alpha), begin_value(beta),
- begin_value(q), stride_major(q), begin_value(z),
- stride_major(z), m, pl, pr, begin_value(dif), &opt_size_work,
- -1, &opt_size_iwork, -1 );
+ detail::tgsen( ijob, wantq, wantz, begin_value(select),
+ size_column(a), begin_value(a), stride_major(a),
+ begin_value(b), stride_major(b), begin_value(alpha),
+ begin_value(beta), begin_value(q), stride_major(q),
+ begin_value(z), stride_major(z), m, pl, pr, begin_value(dif),
+ &opt_size_work, -1, &opt_size_iwork, -1 );
         bindings::detail::array< value_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
         bindings::detail::array< fortran_int_t > tmp_iwork(
                 opt_size_iwork );
- return invoke( ijob, wantq, wantz, select, n, a, b, alpha, beta, q, z,
- m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
+ return invoke( ijob, wantq, wantz, select, a, b, alpha, beta, q, z, m,
+ pl, pr, dif, workspace( tmp_work, tmp_iwork ) );
     }
 
     //
@@ -480,16 +482,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -509,15 +511,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -538,16 +540,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -567,15 +569,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -596,16 +598,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -625,15 +627,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -654,16 +656,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -683,15 +685,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -712,16 +714,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -741,15 +743,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -770,16 +772,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -799,15 +801,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -828,16 +830,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -857,15 +859,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -886,16 +888,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -915,15 +917,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -944,16 +946,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -973,15 +975,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1002,16 +1004,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1031,15 +1033,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1060,16 +1062,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1089,15 +1091,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1118,16 +1120,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1147,15 +1149,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1176,16 +1178,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1205,15 +1207,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1234,16 +1236,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1263,15 +1265,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1292,16 +1294,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1321,15 +1323,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1350,16 +1352,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1379,15 +1381,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1408,16 +1410,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1437,15 +1439,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1466,16 +1468,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1495,15 +1497,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1524,16 +1526,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1553,15 +1555,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1582,16 +1584,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1611,15 +1613,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1640,16 +1642,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1669,15 +1671,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1698,16 +1700,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1727,15 +1729,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1756,16 +1758,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1785,15 +1787,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1814,16 +1816,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1843,15 +1845,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1872,16 +1874,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1901,15 +1903,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1930,16 +1932,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -1959,16 +1961,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -1989,16 +1990,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2018,15 +2019,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2047,16 +2048,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2076,16 +2077,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2106,16 +2106,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2135,15 +2135,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2164,16 +2164,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2193,16 +2193,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2223,16 +2222,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2252,16 +2251,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2282,16 +2280,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2311,16 +2309,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2341,16 +2338,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2370,15 +2367,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2399,16 +2396,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2428,15 +2425,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2457,16 +2454,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2486,15 +2483,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2515,16 +2512,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2544,15 +2541,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2573,16 +2570,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2602,15 +2599,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2631,16 +2628,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2660,15 +2657,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2689,16 +2686,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2718,15 +2715,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2747,16 +2744,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2776,15 +2773,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2805,16 +2802,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2834,15 +2831,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2863,16 +2860,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2892,16 +2889,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2922,16 +2918,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -2951,15 +2947,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -2980,16 +2976,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3009,16 +3005,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3039,16 +3034,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3068,15 +3063,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3097,16 +3092,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3126,16 +3121,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3156,16 +3150,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3185,16 +3179,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3215,16 +3208,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3244,16 +3237,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3274,16 +3266,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3303,15 +3295,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3332,16 +3324,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3361,16 +3353,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3391,16 +3382,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3420,15 +3411,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3449,16 +3440,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3478,16 +3469,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3508,16 +3498,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3537,15 +3527,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3566,16 +3556,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3595,16 +3585,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3625,16 +3614,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3654,15 +3643,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3683,16 +3672,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3712,16 +3701,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3742,16 +3730,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3771,15 +3759,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3800,16 +3788,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3829,16 +3817,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3859,16 +3846,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3888,15 +3875,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3917,16 +3904,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -3946,16 +3933,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -3976,16 +3962,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4005,15 +3991,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4034,16 +4020,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4063,16 +4049,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4093,16 +4078,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4122,16 +4107,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4152,16 +4136,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4181,16 +4165,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4211,16 +4194,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4240,15 +4223,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4269,16 +4252,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4298,15 +4281,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4327,16 +4310,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4356,15 +4339,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4385,16 +4368,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4414,15 +4397,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4443,16 +4426,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4472,15 +4455,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4501,16 +4484,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4530,15 +4513,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4559,16 +4542,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4588,15 +4571,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4617,16 +4600,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4646,15 +4629,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4675,16 +4658,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4704,15 +4687,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4733,16 +4716,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4762,16 +4745,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4792,16 +4774,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4821,15 +4803,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4850,16 +4832,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4879,16 +4861,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4909,16 +4890,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4938,15 +4919,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -4967,16 +4948,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -4996,16 +4977,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5026,16 +5006,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5055,16 +5035,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5085,16 +5064,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5114,16 +5093,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5144,16 +5122,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5173,15 +5151,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5202,16 +5180,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5231,16 +5209,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5261,16 +5238,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5290,15 +5267,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5319,16 +5296,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5348,16 +5325,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5378,16 +5354,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5407,15 +5383,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5436,16 +5412,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5465,16 +5441,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5495,16 +5470,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5524,15 +5499,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5553,16 +5528,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5582,16 +5557,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5612,16 +5586,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5641,15 +5615,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5670,16 +5644,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5699,16 +5673,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5729,16 +5702,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5758,15 +5731,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5787,16 +5760,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5816,16 +5789,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5846,16 +5818,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5875,15 +5847,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5904,16 +5876,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5933,16 +5905,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -5963,16 +5934,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -5992,16 +5963,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6022,16 +5992,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6051,16 +6021,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6081,16 +6050,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6110,15 +6079,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6139,16 +6108,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6168,16 +6137,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6198,16 +6166,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6227,15 +6195,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6256,17 +6224,17 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
- return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
-}
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
+ return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
+}
 
 //
 // Overloaded function for tgsen. Its overload differs for
@@ -6285,16 +6253,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6315,16 +6282,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6344,15 +6311,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6373,16 +6340,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6402,16 +6369,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6432,16 +6398,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6461,15 +6427,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6490,16 +6456,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6519,16 +6485,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6549,16 +6514,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6578,15 +6543,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6607,16 +6572,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6636,16 +6601,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6666,16 +6630,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6695,15 +6659,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6724,16 +6688,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6753,16 +6717,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6783,16 +6746,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6812,15 +6775,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6841,16 +6804,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6870,16 +6833,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6900,16 +6862,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6929,16 +6891,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -6959,16 +6920,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -6988,16 +6949,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7018,16 +6978,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7047,15 +7007,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7076,16 +7036,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7105,16 +7065,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7135,16 +7094,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7164,15 +7123,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7193,16 +7152,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7222,16 +7181,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ const MatrixQ& q, const MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7252,16 +7210,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7281,15 +7239,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7310,16 +7268,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7339,16 +7297,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7369,16 +7326,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7398,15 +7355,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7427,16 +7384,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7456,16 +7413,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7486,16 +7442,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7515,15 +7471,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7544,16 +7500,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7573,16 +7529,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7603,16 +7558,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7632,15 +7587,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7661,16 +7616,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7690,16 +7645,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7720,16 +7674,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7749,15 +7703,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
         fortran_int_t& m, typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7778,16 +7732,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7807,16 +7761,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7837,16 +7790,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7866,16 +7819,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7896,16 +7848,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7925,16 +7877,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, const MatrixQ& q,
- const MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
- typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, VectorDIF& dif ) {
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, const MatrixQ& q, const MatrixZ& z,
+ fortran_int_t& m, typename remove_imaginary< typename value<
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -7955,16 +7906,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -7984,15 +7935,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8013,16 +7964,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8042,15 +7993,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8071,16 +8022,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8100,15 +8051,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8129,16 +8080,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8158,15 +8109,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8187,16 +8138,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8216,15 +8167,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8245,16 +8196,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8274,15 +8225,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8303,16 +8254,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8332,15 +8283,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8361,16 +8312,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8390,15 +8341,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8419,16 +8370,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8448,15 +8399,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8477,16 +8428,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8506,15 +8457,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8535,16 +8486,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8564,15 +8515,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
- VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8593,16 +8544,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8622,15 +8573,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai, VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8651,16 +8602,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8680,15 +8631,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8709,16 +8660,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8738,15 +8689,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8767,16 +8718,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8796,15 +8747,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8825,16 +8776,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8854,15 +8805,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8883,16 +8834,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8912,15 +8863,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8941,16 +8892,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -8970,15 +8921,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -8999,16 +8950,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9028,15 +8979,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai,
- const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9057,16 +9008,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9086,15 +9037,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, VectorALPHAI& alphai, const VectorBETA& beta,
+ MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9115,16 +9066,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9144,15 +9095,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9173,16 +9124,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9202,15 +9153,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9231,16 +9182,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9260,15 +9211,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9289,16 +9240,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9318,15 +9269,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, const VectorALPHAR& alphar,
- VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q, MatrixZ& z,
- fortran_int_t& m, typename remove_imaginary< typename value<
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
+ typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9347,16 +9298,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9376,15 +9327,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9405,16 +9356,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9434,16 +9385,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9464,16 +9414,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9493,15 +9443,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9522,16 +9472,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9551,16 +9501,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, const MatrixB& b, VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, const MatrixB& b,
+ VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9581,16 +9530,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
         Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9610,15 +9559,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- MatrixB& b, const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorSELECT& select, MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
         const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
         MatrixA >::type >::type& pl, typename remove_imaginary<
         typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9639,16 +9588,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9668,16 +9617,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n,
- const MatrixA& a, MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, const MatrixA& a, MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9698,16 +9646,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif, Workspace work ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif,
+ Workspace work ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, work );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, work );
 }
 
 //
@@ -9727,16 +9675,15 @@
         typename MatrixQ, typename MatrixZ, typename VectorDIF >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
         const logical_t wantq, const logical_t wantz,
- const VectorSELECT& select, const fortran_int_t n, MatrixA& a,
- const MatrixB& b, const VectorALPHAR& alphar,
- const VectorALPHAI& alphai, const VectorBETA& beta, MatrixQ& q,
- MatrixZ& z, fortran_int_t& m, typename remove_imaginary<
- typename value< MatrixA >::type >::type& pl,
+ const VectorSELECT& select, MatrixA& a, const MatrixB& b,
+ const VectorALPHAR& alphar, const VectorALPHAI& alphai,
+ const VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m,
         typename remove_imaginary< typename value<
- MatrixA >::type >::type& pr, const VectorDIF& dif ) {
+ MatrixA >::type >::type& pl, typename remove_imaginary<
+ typename value< MatrixA >::type >::type& pr, const VectorDIF& dif ) {
     return tgsen_impl< typename value< MatrixA >::type >::invoke( ijob,
- wantq, wantz, select, n, a, b, alphar, alphai, beta, q, z, m, pl,
- pr, dif, optimal_workspace() );
+ wantq, wantz, select, a, b, alphar, alphai, beta, q, z, m, pl, pr,
+ dif, optimal_workspace() );
 }
 
 //
@@ -9757,16 +9704,16 @@
         typename Workspace >
 inline std::ptrdiff_t tgsen( const fortran_int_t ijob,
        &