Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r64859 - in sandbox/numeric_bindings: boost/numeric/bindings/lapack/computational libs/numeric/bindings/doc/lapack/computational libs/numeric/bindings/tools/templates/computational
From: rutger_at_[hidden]
Date: 2010-08-17 06:39:15


Author: rutger
Date: 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
New Revision: 64859
URL: http://svn.boost.org/trac/boost/changeset/64859

Log:
Fixed orm* functions (added k as a trait of tau) of lapack computational routines

Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp | 45 +++++++++++++-------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp | 52 +++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp | 50 ++++++++++++++---------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp | 52 +++++++++++++++----------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp | 47 +++++++++++++--------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp | 61 +++++++++++++++++++++++++++---------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp | 66 +++++++++++++++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp | 64 +++++++++++++++++++++++++++-----------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp | 66 +++++++++++++++++++++++++++------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp | 61 ++++++++++++++++++++++++++----------
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormbr.qbk | 4 +-
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormlq.qbk | 4 +-
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormql.qbk | 4 +-
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrq.qbk | 4 +-
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrz.qbk | 4 +-
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmbr.qbk | 7 +++
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmlq.qbk | 7 +++
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmql.qbk | 7 +++
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrq.qbk | 7 +++
   sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrz.qbk | 7 +++
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp | 14 ++++++++
   21 files changed, 400 insertions(+), 233 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -104,8 +104,8 @@
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
     static std::ptrdiff_t invoke( const char vect, const Side side,
- const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
- MatrixC& c, detail::workspace1< WORK > work ) {
+ const MatrixA& a, const VectorTAU& tau, MatrixC& c,
+ detail::workspace1< WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -118,6 +118,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= 0 );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -129,12 +130,12 @@
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
- BOOST_ASSERT( k >= 0 );
         BOOST_ASSERT( vect == 'Q' || vect == 'P' );
         return detail::ormbr( vect, side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -149,14 +150,14 @@
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
     static std::ptrdiff_t invoke( const char vect, const Side side,
- const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
- MatrixC& c, minimal_workspace ) {
+ const MatrixA& a, const VectorTAU& tau, MatrixC& c,
+ minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( vect, side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -169,20 +170,20 @@
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
     static std::ptrdiff_t invoke( const char vect, const Side side,
- const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
- MatrixC& c, optimal_workspace ) {
+ const MatrixA& a, const VectorTAU& tau, MatrixC& c,
+ optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::ormbr( vect, side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( vect, side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -215,10 +216,10 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
-ormbr( const char vect, const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c, Workspace work ) {
+ormbr( const char vect, const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, Workspace work ) {
     return ormbr_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( vect, side, k, a, tau, c, work );
+ MatrixA >::type >::invoke( vect, side, a, tau, c, work );
 }
 
 //
@@ -229,10 +230,10 @@
         typename MatrixC >
 inline typename boost::disable_if< detail::is_workspace< MatrixC >,
         std::ptrdiff_t >::type
-ormbr( const char vect, const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c ) {
+ormbr( const char vect, const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c ) {
     return ormbr_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( vect, side, k, a, tau, c,
+ MatrixA >::type >::invoke( vect, side, a, tau, c,
             optimal_workspace() );
 }
 

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -102,9 +102,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -117,7 +117,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -128,13 +128,14 @@
                 bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- k) );
+ bindings::size(tau)) );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::ormlq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -148,15 +149,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -168,21 +168,20 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::ormlq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -215,10 +214,10 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
-ormlq( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c, Workspace work ) {
+ormlq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
     return ormlq_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c, work );
+ MatrixA >::type >::invoke( side, a, tau, c, work );
 }
 
 //
@@ -229,11 +228,10 @@
         typename MatrixC >
 inline typename boost::disable_if< detail::is_workspace< MatrixC >,
         std::ptrdiff_t >::type
-ormlq( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c ) {
+ormlq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
     return ormlq_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c,
- optimal_workspace() );
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -102,9 +102,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -117,7 +117,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -130,9 +130,10 @@
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::ormql( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -146,15 +147,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -166,21 +166,20 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::ormql( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -213,10 +212,10 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
-ormql( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c, Workspace work ) {
+ormql( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
     return ormql_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c, work );
+ MatrixA >::type >::invoke( side, a, tau, c, work );
 }
 
 //
@@ -227,11 +226,10 @@
         typename MatrixC >
 inline typename boost::disable_if< detail::is_workspace< MatrixC >,
         std::ptrdiff_t >::type
-ormql( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c ) {
+ormql( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
     return ormql_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c,
- optimal_workspace() );
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -102,9 +102,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -117,7 +117,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -128,13 +128,14 @@
                 bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- k) );
+ bindings::size(tau)) );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::ormrq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -148,15 +149,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -168,21 +168,20 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::ormrq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -215,10 +214,10 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
-ormrq( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c, Workspace work ) {
+ormrq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
     return ormrq_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c, work );
+ MatrixA >::type >::invoke( side, a, tau, c, work );
 }
 
 //
@@ -229,11 +228,10 @@
         typename MatrixC >
 inline typename boost::disable_if< detail::is_workspace< MatrixC >,
         std::ptrdiff_t >::type
-ormrq( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c ) {
+ormrq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
     return ormrq_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c,
- optimal_workspace() );
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -103,9 +103,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -118,7 +118,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -129,12 +129,13 @@
                 bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- k) );
+ bindings::size(tau)) );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::ormrz( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::size_column_op(a,
- trans()), bindings::begin_value(a), bindings::stride_major(a),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
                 bindings::begin_value(tau), bindings::begin_value(c),
                 bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
@@ -150,15 +151,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -170,21 +170,21 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::ormrz( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::size_column_op(a,
- trans()), bindings::begin_value(a), bindings::stride_major(a),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
                 bindings::begin_value(tau), bindings::begin_value(c),
                 bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -217,10 +217,10 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
-ormrz( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c, Workspace work ) {
+ormrz( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
     return ormrz_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c, work );
+ MatrixA >::type >::invoke( side, a, tau, c, work );
 }
 
 //
@@ -231,11 +231,10 @@
         typename MatrixC >
 inline typename boost::disable_if< detail::is_workspace< MatrixC >,
         std::ptrdiff_t >::type
-ormrz( const Side side, const fortran_int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c ) {
+ormrz( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
     return ormrz_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( side, k, a, tau, c,
- optimal_workspace() );
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
 }
 
 } // namespace lapack

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -151,8 +151,8 @@
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
     static std::ptrdiff_t invoke( const char vect, const Side side,
- const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
- MatrixC& c, detail::workspace1< WORK > work ) {
+ const MatrixA& a, const VectorTAU& tau, MatrixC& c,
+ detail::workspace1< WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -165,6 +165,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( bindings::size(tau) >= 0 );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -176,12 +177,12 @@
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
- BOOST_ASSERT( k >= 0 );
         BOOST_ASSERT( vect == 'Q' || vect == 'P' );
         return detail::unmbr( vect, side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -196,14 +197,14 @@
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
     static std::ptrdiff_t invoke( const char vect, const Side side,
- const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
- MatrixC& c, minimal_workspace ) {
+ const MatrixA& a, const VectorTAU& tau, MatrixC& c,
+ minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( vect, side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -216,20 +217,20 @@
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
     static std::ptrdiff_t invoke( const char vect, const Side side,
- const fortran_int_t k, const MatrixA& a, const VectorTAU& tau,
- MatrixC& c, optimal_workspace ) {
+ const MatrixA& a, const VectorTAU& tau, MatrixC& c,
+ optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::unmbr( vect, side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( vect, side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -372,6 +373,34 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
+unmbr( const char vect, const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, Workspace work ) {
+ return unmbr_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( vect, side, a, tau, c, work );
+}
+
+//
+// Overloaded function for unmbr. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC >
+inline typename boost::disable_if< detail::is_workspace< MatrixC >,
+ std::ptrdiff_t >::type
+unmbr( const char vect, const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c ) {
+ return unmbr_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( vect, side, a, tau, c,
+ optimal_workspace() );
+}
+//
+// Overloaded function for unmbr. Its overload differs for
+// * User-defined workspace
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC, typename Workspace >
+inline typename boost::enable_if< detail::is_workspace< Workspace >,
+ std::ptrdiff_t >::type
 unmbr( const char vect, const Side side, const fortran_int_t k,
         const MatrixA& a, const VectorTAU& tau, MatrixC& c, Workspace work ) {
     return unmbr_impl< typename bindings::value_type<

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -149,9 +149,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -164,7 +164,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -175,13 +175,14 @@
                 bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- k) );
+ bindings::size(tau)) );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::unmlq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -195,15 +196,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -215,21 +215,20 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::unmlq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -373,6 +372,33 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
+unmlq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
+ return unmlq_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, work );
+}
+
+//
+// Overloaded function for unmlq. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC >
+inline typename boost::disable_if< detail::is_workspace< MatrixC >,
+ std::ptrdiff_t >::type
+unmlq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
+ return unmlq_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
+}
+//
+// Overloaded function for unmlq. Its overload differs for
+// * User-defined workspace
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC, typename Workspace >
+inline typename boost::enable_if< detail::is_workspace< Workspace >,
+ std::ptrdiff_t >::type
 unmlq( const Side side, const fortran_int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c, Workspace work ) {
     return unmlq_impl< typename bindings::value_type<

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -149,9 +149,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -164,7 +164,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -177,9 +177,10 @@
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::unmql( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -193,15 +194,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -213,21 +213,20 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::unmql( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -369,6 +368,33 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
+unmql( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
+ return unmql_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, work );
+}
+
+//
+// Overloaded function for unmql. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC >
+inline typename boost::disable_if< detail::is_workspace< MatrixC >,
+ std::ptrdiff_t >::type
+unmql( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
+ return unmql_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
+}
+//
+// Overloaded function for unmql. Its overload differs for
+// * User-defined workspace
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC, typename Workspace >
+inline typename boost::enable_if< detail::is_workspace< Workspace >,
+ std::ptrdiff_t >::type
 unmql( const Side side, const fortran_int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c, Workspace work ) {
     return unmql_impl< typename bindings::value_type<

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -149,9 +149,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -164,7 +164,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -175,13 +175,14 @@
                 bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- k) );
+ bindings::size(tau)) );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::unmrq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
                 bindings::size(work.select(real_type())) );
     }
@@ -195,15 +196,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -215,21 +215,20 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::unmrq( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::begin_value(c), bindings::stride_major(c),
- &opt_size_work, -1 );
+ bindings::size_column(c), bindings::size(tau),
+ bindings::begin_value(a), bindings::stride_major(a),
+ bindings::begin_value(tau), bindings::begin_value(c),
+ bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -373,6 +372,33 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
+unmrq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
+ return unmrq_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, work );
+}
+
+//
+// Overloaded function for unmrq. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC >
+inline typename boost::disable_if< detail::is_workspace< MatrixC >,
+ std::ptrdiff_t >::type
+unmrq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
+ return unmrq_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
+}
+//
+// Overloaded function for unmrq. Its overload differs for
+// * User-defined workspace
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC, typename Workspace >
+inline typename boost::enable_if< detail::is_workspace< Workspace >,
+ std::ptrdiff_t >::type
 unmrq( const Side side, const fortran_int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c, Workspace work ) {
     return unmrq_impl< typename bindings::value_type<

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -150,9 +150,9 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC, typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, detail::workspace1<
+ WORK > work ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
@@ -165,7 +165,7 @@
                 typename remove_const< typename bindings::value_type<
                 MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(tau) >= k );
+ BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) );
         BOOST_ASSERT( bindings::size(work.select(real_type())) >=
                 min_size_work( side, bindings::size_row(c),
                 bindings::size_column(c) ));
@@ -176,12 +176,13 @@
                 bindings::stride_minor(c) == 1 );
         BOOST_ASSERT( bindings::size_row(c) >= 0 );
         BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- k) );
+ bindings::size(tau)) );
         BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
                 bindings::size_row(c)) );
         return detail::unmrz( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::size_column_op(a,
- trans()), bindings::begin_value(a), bindings::stride_major(a),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
                 bindings::begin_value(tau), bindings::begin_value(c),
                 bindings::stride_major(c),
                 bindings::begin_value(work.select(real_type())),
@@ -197,15 +198,14 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- minimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, minimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         bindings::detail::array< real_type > tmp_work( min_size_work( side,
                 bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -217,21 +217,21 @@
     //
     template< typename Side, typename MatrixA, typename VectorTAU,
             typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c,
- optimal_workspace ) {
+ static std::ptrdiff_t invoke( const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c, optimal_workspace ) {
         namespace bindings = ::boost::numeric::bindings;
         typedef typename result_of::data_order< MatrixC >::type order;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         real_type opt_size_work;
         detail::unmrz( side, trans(), bindings::size_row(c),
- bindings::size_column(c), k, bindings::size_column_op(a,
- trans()), bindings::begin_value(a), bindings::stride_major(a),
+ bindings::size_column(c), bindings::size(tau),
+ bindings::size_column_op(a, trans()),
+ bindings::begin_value(a), bindings::stride_major(a),
                 bindings::begin_value(tau), bindings::begin_value(c),
                 bindings::stride_major(c), &opt_size_work, -1 );
         bindings::detail::array< real_type > tmp_work(
                 traits::detail::to_int( opt_size_work ) );
- return invoke( side, k, a, tau, c, workspace( tmp_work ) );
+ return invoke( side, a, tau, c, workspace( tmp_work ) );
     }
 
     //
@@ -376,6 +376,33 @@
         typename MatrixC, typename Workspace >
 inline typename boost::enable_if< detail::is_workspace< Workspace >,
         std::ptrdiff_t >::type
+unmrz( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c, Workspace work ) {
+ return unmrz_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, work );
+}
+
+//
+// Overloaded function for unmrz. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC >
+inline typename boost::disable_if< detail::is_workspace< MatrixC >,
+ std::ptrdiff_t >::type
+unmrz( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c ) {
+ return unmrz_impl< typename bindings::value_type<
+ MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
+}
+//
+// Overloaded function for unmrz. Its overload differs for
+// * User-defined workspace
+//
+template< typename Side, typename MatrixA, typename VectorTAU,
+ typename MatrixC, typename Workspace >
+inline typename boost::enable_if< detail::is_workspace< Workspace >,
+ std::ptrdiff_t >::type
 unmrz( const Side side, const fortran_int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c, Workspace work ) {
     return unmrz_impl< typename bindings::value_type<

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormbr.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormbr.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormbr.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -9,8 +9,8 @@
 [heading Prototype]
 There is one prototype of `ormbr` available, please see below.
 ``
-ormbr( const char vect, const Side side, const int_t k,
- const MatrixA& a, const VectorTAU& tau, MatrixC& c );
+ormbr( const char vect, const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormlq.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormlq.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormlq.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -9,8 +9,8 @@
 [heading Prototype]
 There is one prototype of `ormlq` available, please see below.
 ``
-ormlq( const Side side, const int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c );
+ormlq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormql.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormql.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormql.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -9,8 +9,8 @@
 [heading Prototype]
 There is one prototype of `ormql` available, please see below.
 ``
-ormql( const Side side, const int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c );
+ormql( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrq.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrq.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrq.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -9,8 +9,8 @@
 [heading Prototype]
 There is one prototype of `ormrq` available, please see below.
 ``
-ormrq( const Side side, const int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c );
+ormrq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrz.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrz.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/ormrz.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -9,8 +9,8 @@
 [heading Prototype]
 There is one prototype of `ormrz` available, please see below.
 ``
-ormrz( const Side side, const int_t k, const MatrixA& a,
- const VectorTAU& tau, MatrixC& c );
+ormrz( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
 ``
 
 

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmbr.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmbr.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmbr.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -7,7 +7,12 @@
 [section unmbr]
 
 [heading Prototype]
-There is one prototype of `unmbr` available, please see below.
+There are two prototypes of `unmbr` available, please see below.
+``
+unmbr( const char vect, const Side side, const MatrixA& a,
+ const VectorTAU& tau, MatrixC& c );
+``
+
 ``
 unmbr( const char vect, const Side side, const int_t k,
         const MatrixA& a, const VectorTAU& tau, MatrixC& c );

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmlq.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmlq.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmlq.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -7,7 +7,12 @@
 [section unmlq]
 
 [heading Prototype]
-There is one prototype of `unmlq` available, please see below.
+There are two prototypes of `unmlq` available, please see below.
+``
+unmlq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
+``
+
 ``
 unmlq( const Side side, const int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c );

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmql.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmql.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmql.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -7,7 +7,12 @@
 [section unmql]
 
 [heading Prototype]
-There is one prototype of `unmql` available, please see below.
+There are two prototypes of `unmql` available, please see below.
+``
+unmql( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
+``
+
 ``
 unmql( const Side side, const int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c );

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrq.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrq.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrq.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -7,7 +7,12 @@
 [section unmrq]
 
 [heading Prototype]
-There is one prototype of `unmrq` available, please see below.
+There are two prototypes of `unmrq` available, please see below.
+``
+unmrq( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
+``
+
 ``
 unmrq( const Side side, const int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c );

Modified: sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrz.qbk
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrz.qbk (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/doc/lapack/computational/unmrz.qbk 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -7,7 +7,12 @@
 [section unmrz]
 
 [heading Prototype]
-There is one prototype of `unmrz` available, please see below.
+There are two prototypes of `unmrz` available, please see below.
+``
+unmrz( const Side side, const MatrixA& a, const VectorTAU& tau,
+ MatrixC& c );
+``
+
 ``
 unmrz( const Side side, const int_t k, const MatrixA& a,
         const VectorTAU& tau, MatrixC& c );

Modified: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp (original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp 2010-08-17 06:39:08 EDT (Tue, 17 Aug 2010)
@@ -3,12 +3,16 @@
 so the init below is pretty useless right now. It only shows how it could work in theory.
 $TEMPLATE[ormbr.all.NQ.init]
 $INTEGER_TYPE nq = bindings::detail::if_left( side, bindings::size_row(c), bindings::size_column(c) );
+$TEMPLATE[ormbr.all.K.trait]
+size,TAU
 $TEMPLATE[ormbr.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormbr.includes]
 #include <boost/numeric/bindings/detail/if_left.hpp>
 $TEMPLATE[ormbr.all.min_size_work]
 return std::max< $INTEGER_TYPE >( 1, bindings::detail::if_left( side, n, m ) );
+$TEMPLATE[ormlq.all.K.trait]
+size,TAU
 $TEMPLATE[ormlq.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormlq.includes]
@@ -23,30 +27,40 @@
 #include <boost/numeric/bindings/detail/if_left.hpp>
 $TEMPLATE[ormqr.all.min_size_work]
 return std::max< $INTEGER_TYPE >( 1, bindings::detail::if_left( side, n, m ) );
+$TEMPLATE[ormrq.all.K.trait]
+size,TAU
 $TEMPLATE[ormrq.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormrq.includes]
 #include <boost/numeric/bindings/detail/if_left.hpp>
 $TEMPLATE[ormrq.all.min_size_work]
 return std::max< $INTEGER_TYPE >( 1, bindings::detail::if_left( side, n, m ) );
+$TEMPLATE[ormrz.all.K.trait]
+size,TAU
 $TEMPLATE[ormrz.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormrz.includes]
 #include <boost/numeric/bindings/detail/if_left.hpp>
 $TEMPLATE[ormrz.all.min_size_work]
 return std::max< $INTEGER_TYPE >( 1, bindings::detail::if_left( side, n, m ) );
+$TEMPLATE[ormtr.all.K.trait]
+size,TAU
 $TEMPLATE[ormtr.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormtr.includes]
 #include <boost/numeric/bindings/detail/if_left.hpp>
 $TEMPLATE[ormtr.all.min_size_work]
 return std::max< $INTEGER_TYPE >( 1, bindings::detail::if_left( side, n, m ) );
+$TEMPLATE[ormql.all.K.trait]
+size,TAU
 $TEMPLATE[ormql.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormql.includes]
 #include <boost/numeric/bindings/detail/if_left.hpp>
 $TEMPLATE[ormql.all.min_size_work]
 return std::max< $INTEGER_TYPE >( 1, bindings::detail::if_left( side, n, m ) );
+$TEMPLATE[ormhr.all.K.trait]
+size,TAU
 $TEMPLATE[ormhr.all.min_size_work.args]
 SIDE,M,N
 $TEMPLATE[ormhr.includes]


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk