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

Subject: [Boost-commit] svn:boost r51653 - in sandbox/numeric_bindings: boost/numeric/bindings/lapack/computational boost/numeric/bindings/lapack/driver libs/numeric/bindings/tools
From: rutger_at_[hidden]
Date: 2009-03-08 13:49:15

Author: rutger
Date: 2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
New Revision: 51653
URL: http://svn.boost.org/trac/boost/changeset/51653

Log:
Fixed a bug in the assert part for workspace-related vector sizes.

Text files modified: 
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp |    10 +++++-----                              
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbcon.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbrfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp |     9 +++++----                               
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggbal.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggqrf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggrqf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ggsvp.hpp |    30 +++++++++++++++---------------          
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/herfs.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp  |    10 +++++-----                              
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormbr.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormlq.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormql.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrq.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormrz.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp |     6 +++---                                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbcon.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/porfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp |    20 ++++++++++----------                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/syrfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgevc.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgexc.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsen.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmbr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmlq.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmql.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrq.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmrz.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp         |    20 ++++++++++----------                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp        |    24 ++++++++++++------------                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp         |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp        |    17 +++++++++--------                       
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp         |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp         |    11 ++++++-----                             
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp        |    21 +++++++++++----------                   
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp        |    15 ++++++++-------                         
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp        |    15 ++++++++-------                         
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp        |    22 +++++++++++-----------                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp        |    13 +++++++------                           
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp         |    20 ++++++++++----------                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp        |    28 ++++++++++++++--------------            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp         |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp        |    29 +++++++++++++++--------------           
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp        |    10 +++++-----                              
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp        |    10 +++++-----                              
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp        |    22 +++++++++++-----------                  
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp        |    21 +++++++++++----------                   
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp        |    12 ++++++------                            
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp         |     4 ++--                                    
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp        |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp         |     8 ++++----                                
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp        |    16 ++++++++--------                        
   sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py                 |     4 ++--                                    
   182 files changed, 913 insertions(+), 904 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsdc.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -80,10 +80,10 @@
         assert( compq == 'N' || compq == 'P' || compq == 'I' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                compq, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( compq, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::bdsdc( uplo, compq, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(u),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/bdsqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -108,9 +108,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(u) >= std::max(1,
                 traits::matrix_num_rows(u)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n, traits::matrix_num_columns(vt), traits::matrix_num_rows(u),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n, traits::matrix_num_columns(vt),
+                traits::matrix_num_rows(u), traits::matrix_num_columns(c) ));
 #endif
         detail::bdsqr( uplo, n, traits::matrix_num_columns(vt),
                 traits::matrix_num_rows(u), traits::matrix_num_columns(c),
@@ -181,9 +181,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(u) >= std::max(1,
                 traits::matrix_num_rows(u)) );
-        assert( traits::vector_size(work.select(real_type()) >=
+        assert( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n, traits::matrix_num_columns(vt),
-                traits::matrix_num_rows(u), traits::matrix_num_columns(c) )));
+                traits::matrix_num_rows(u), traits::matrix_num_columns(c) ));
 #endif
         detail::bdsqr( uplo, n, traits::matrix_num_columns(vt),
                 traits::matrix_num_rows(u), traits::matrix_num_columns(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gbbrd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -119,8 +119,8 @@
         assert( traits::leading_dimension(ab) >= kl+ku+1 );
         assert( traits::vector_size(d) >= std::min(m,n) );
         assert( traits::vector_size(e) >= std::min(m,n)-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                m, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( m, n ));
 #endif
         detail::gbbrd( vect, m, n, traits::matrix_num_columns(c), kl, ku,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
@@ -197,10 +197,10 @@
         assert( traits::leading_dimension(ab) >= kl+ku+1 );
         assert( traits::vector_size(d) >= std::min(m,n) );
         assert( traits::vector_size(e) >= std::min(m,n)-1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( m, n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( m, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( m, n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( m, n ));
 #endif
         detail::gbbrd( vect, m, n, traits::matrix_num_columns(c), kl, ku,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -93,10 +93,10 @@
         assert( ku >= 0 );
         assert( traits::leading_dimension(ab) >= 2 );
         assert( traits::vector_size(ipiv) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::gbcon( norm, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(ipiv),
@@ -158,10 +158,10 @@
         assert( ku >= 0 );
         assert( traits::leading_dimension(ab) >= 2 );
         assert( traits::vector_size(ipiv) >= n );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::gbcon( norm, n, kl, ku, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), traits::vector_storage(ipiv),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -126,10 +126,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::gbrfs( trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
@@ -219,10 +219,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::gbrfs( trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gebrd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -109,8 +109,9 @@
         assert( traits::vector_size(taup) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(a) ));
 #endif
         detail::gebrd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -187,9 +188,9 @@
         assert( traits::vector_size(taup) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
-                traits::matrix_num_columns(a) )));
+                traits::matrix_num_columns(a) ));
 #endif
         detail::gebrd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gecon.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -85,10 +85,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gecon( norm, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -143,10 +143,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gecon( norm, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gehrd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,8 +88,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::gehrd( traits::matrix_num_columns(a), ilo, ihi,
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -145,8 +145,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::gehrd( traits::matrix_num_columns(a), ilo, ihi,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gelqf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,8 +88,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a) ));
 #endif
         detail::gelqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -148,8 +148,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_rows(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_rows(a) ));
 #endif
         detail::gelqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqlf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,8 +88,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::geqlf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -148,8 +148,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::geqlf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqp3.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -91,8 +91,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::geqp3( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -153,10 +153,10 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::geqp3( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/geqrf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,8 +88,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::geqrf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -148,8 +148,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::geqrf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -123,10 +123,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gerfs( trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
@@ -215,10 +215,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gerfs( trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gerqf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,8 +88,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::gerqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -148,8 +148,8 @@
         assert( traits::vector_size(tau) >=
                 std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::gerqf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/getri.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,8 +81,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::getri( traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -135,8 +135,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::getri( traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -99,8 +99,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ggbal( job, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
@@ -162,8 +162,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ggbal( job, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -112,8 +112,8 @@
         assert( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ggqrf( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -192,8 +192,8 @@
         assert( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ggqrf( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -112,8 +112,8 @@
         assert( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ggrqf( traits::matrix_num_rows(a), traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),
@@ -192,8 +192,8 @@
         assert( traits::vector_size(taub) >=
                 std::min(traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ggrqf( traits::matrix_num_rows(a), traits::matrix_num_rows(b),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -134,13 +134,13 @@
                 traits::matrix_num_rows(a)) );
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_tau( traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(b), traits::matrix_num_rows(a),
-                traits::matrix_num_rows(b) )));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_tau( traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(b),
+                traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
 #endif
         detail::ggsvp( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b),
@@ -237,15 +237,15 @@
                 traits::matrix_num_rows(a)) );
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_tau( traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_tau( traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(b),
-                traits::matrix_num_rows(a), traits::matrix_num_rows(b) )));
+                traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
 #endif
         detail::ggsvp( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/gtrfs.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -151,10 +151,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::gtrfs( trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
@@ -267,10 +267,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::gtrfs( trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,10 +81,10 @@
         assert( kb >= kb );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hbgst( vect, traits::matrix_uplo_tag(a), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,8 +77,8 @@
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd+1 );
         assert( traits::vector_size(d) >= n );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
 #endif
         detail::hbtrd( vect, traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hecon.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -67,8 +67,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::hecon( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -97,10 +97,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::herfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,8 +77,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(d) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work(  )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work(  ));
 #endif
         detail::hetrd( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetrf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -64,8 +64,8 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work(  )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work(  ));
 #endif
         detail::hetrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hetri.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -64,8 +64,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::hetri( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hgeqz.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -128,8 +128,8 @@
         assert( traits::matrix_num_columns(h) >= 0 );
         assert( traits::vector_size(alphar) >= traits::matrix_num_columns(h) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(h) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(h) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(h) ));
 #endif
         detail::hgeqz( job, compq, compz, traits::matrix_num_columns(h), ilo,
                 traits::matrix_num_columns(h), traits::matrix_storage(h),
@@ -221,10 +221,10 @@
         assert( traits::matrix_num_columns(h) >= 0 );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(h) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(h) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(h) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(h) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(h) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(h) ));
 #endif
         detail::hgeqz( job, compq, compz, traits::matrix_num_columns(h), ilo,
                 traits::matrix_num_columns(h), traits::matrix_storage(h),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -93,10 +93,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hsein.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -127,8 +127,8 @@
         assert( traits::vector_size(wr) >= traits::matrix_num_columns(h) );
         assert( traits::vector_size(wi) >= traits::matrix_num_columns(h) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(h), ?2 )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(h), ?2 ));
 #endif
         detail::hsein( side, eigsrc, initv, traits::vector_storage(select),
                 traits::matrix_num_columns(h), traits::matrix_storage(h),
@@ -212,10 +212,10 @@
                 traits::matrix_num_columns(h)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(h) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(h) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(h) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(h) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(h) ));
 #endif
         detail::hsein( side, eigsrc, initv, traits::vector_storage(select),
                 traits::matrix_num_columns(h), traits::matrix_storage(h),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hseqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -102,8 +102,8 @@
         assert( job == 'E' || job == 'S' );
         assert( compz == 'N' || compz == 'I' || compz == 'V' );
         assert( traits::vector_size(wr) >= traits::matrix_num_columns(h) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::hseqr( job, compz, traits::matrix_num_columns(h), ilo, ihi,
                 traits::matrix_storage(h), traits::leading_dimension(h),
@@ -164,8 +164,8 @@
 #ifndef NDEBUG
         assert( job == 'E' || job == 'S' );
         assert( compz == 'N' || compz == 'I' || compz == 'V' );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::hseqr( job, compz, traits::matrix_num_columns(h), ilo, ihi,
                 traits::matrix_storage(h), traits::leading_dimension(h),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,10 +73,10 @@
         
 #ifndef NDEBUG
         assert( n >= 1 );
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_v( n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_isgn( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_v( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_isgn( n ));
 #endif
         detail::lacon( n, traits::vector_storage(work.select(real_type())),
                 traits::vector_storage(x),
@@ -122,8 +122,8 @@
         
 #ifndef NDEBUG
         assert( n >= 1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_v( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_v( n ));
 #endif
         detail::lacon( n, traits::vector_storage(work.select(value_type())),
                 traits::vector_storage(x), est, kase );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -91,10 +91,10 @@
         assert( traits::vector_size(d) >= n );
         assert( traits::vector_size(e) >= n );
         assert( traits::vector_size(e2) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::leading_dimension(ab) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::leading_dimension(ab) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::leading_dimension(ab) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::leading_dimension(ab) ));
 #endif
         detail::laebz( ijob, nitmax, n, traits::leading_dimension(ab), minp,
                 nbmin, abstol, reltol, pivmin, traits::vector_storage(d),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -86,9 +86,9 @@
         assert( side == 'L' || side == 'R' );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::larz( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), l, traits::vector_storage(v),
@@ -143,9 +143,9 @@
         assert( side == 'L' || side == 'R' );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::larz( side, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), l, traits::vector_storage(v),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -84,8 +84,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a) ));
 #endif
         detail::latrz( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(a),
@@ -134,8 +134,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_rows(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_rows(a) ));
 #endif
         detail::latrz( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opgtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -71,8 +71,8 @@
         assert( traits::vector_size(tau) >= traits::matrix_num_columns(q)-1 );
         assert( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(q)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(q) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(q) ));
 #endif
         detail::opgtr( uplo, traits::matrix_num_columns(q),
                 traits::vector_storage(ap), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/opmtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,9 +73,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::opmtr( side, uplo, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), traits::vector_storage(ap),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgbr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -65,8 +65,8 @@
         assert( m >= 0 );
         assert( k >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                m, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( m, n ));
 #endif
         detail::orgbr( vect, m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orghr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -64,8 +64,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::vector_size(tau) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::orghr( n, ilo, ihi, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -66,8 +66,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                m )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( m ));
 #endif
         detail::orglq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -66,8 +66,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::orgql( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -66,8 +66,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::orgqr( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -66,8 +66,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                m )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( m ));
 #endif
         detail::orgrq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -65,8 +65,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::vector_size(tau) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::orgtr( traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -79,9 +79,9 @@
         assert( traits::vector_size(tau) >= std::min(?NQ,k) );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormbr( vect, side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormhr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -78,9 +78,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormhr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), ilo, ihi,

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,9 +77,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormlq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -76,9 +76,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormql( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -76,9 +76,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormqr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,9 +77,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormrq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -78,8 +78,8 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::ormrz( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ormtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,9 +77,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( side, traits::matrix_num_rows(c),
+                traits::matrix_num_columns(c) ));
 #endif
         detail::ormtr( side, traits::matrix_uplo_tag(a), trans,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -86,10 +86,10 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd+1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::pbcon( uplo, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), anorm, rcond,
@@ -144,10 +144,10 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd+1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::pbcon( uplo, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), anorm, rcond,

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -120,10 +120,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::pbrfs( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
@@ -204,10 +204,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::pbrfs( traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pocon.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -85,10 +85,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::pocon( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -142,10 +142,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::pocon( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -122,10 +122,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::porfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
@@ -210,10 +210,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::porfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -115,10 +115,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::pprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
@@ -195,10 +195,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::pprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pteqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -87,8 +87,8 @@
         assert( n >= 0 );
         assert( traits::vector_size(d) >= n );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::pteqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
@@ -137,8 +137,8 @@
         assert( n >= 0 );
         assert( traits::vector_size(d) >= n );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::pteqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ptrfs.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -123,8 +123,8 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::ptrfs( n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
@@ -210,10 +210,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::ptrfs( uplo, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,8 +77,8 @@
         assert( kb >= kb );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::sbgst( vect, traits::matrix_uplo_tag(a), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -78,8 +78,8 @@
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd+1 );
         assert( traits::vector_size(d) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::sbtrd( vect, traits::matrix_uplo_tag(a), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -119,10 +119,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::sprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),
@@ -204,10 +204,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::sprfs( traits::matrix_uplo_tag(a), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stebz.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -86,10 +86,10 @@
         assert( traits::vector_size(e) >= n-1 );
         assert( traits::vector_size(w) >= n );
         assert( traits::vector_size(isplit) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::stebz( range, order, n, vl, vu, il, iu, abstol,
                 traits::vector_storage(d), traits::vector_storage(e), m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stedc.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -97,10 +97,10 @@
         assert( compz == 'N' || compz == 'I' || compz == 'V' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( compz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( compz, n ));
 #endif
         detail::stedc( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
@@ -167,12 +167,12 @@
         assert( compz == 'N' || compz == 'I' || compz == 'V' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( compz, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( compz, n ));
 #endif
         detail::stedc( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stegr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -113,10 +113,10 @@
         assert( traits::vector_size(d) >= n );
         assert( traits::vector_size(e) >= n );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::stegr( jobz, range, n, traits::vector_storage(d),
                 traits::vector_storage(e), vl, vu, il, iu, abstol, m,
@@ -204,10 +204,10 @@
         assert( traits::vector_size(d) >= n );
         assert( traits::vector_size(e) >= n );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::stegr( jobz, range, n, traits::vector_storage(d),
                 traits::vector_storage(e), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/stein.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -107,10 +107,10 @@
         assert( traits::vector_size(w) >= n );
         assert( traits::vector_size(isplit) >= n );
         assert( traits::leading_dimension(z) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::stein( n, traits::vector_storage(d),
                 traits::vector_storage(e), m, traits::vector_storage(w),
@@ -191,10 +191,10 @@
         assert( traits::vector_size(w) >= n );
         assert( traits::vector_size(isplit) >= n );
         assert( traits::leading_dimension(z) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::stein( n, traits::vector_storage(d),
                 traits::vector_storage(e), m, traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/steqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -86,8 +86,8 @@
         assert( compz == 'N' || compz == 'V' || compz == 'I' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::steqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),
@@ -136,8 +136,8 @@
         assert( compz == 'N' || compz == 'V' || compz == 'I' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::steqr( compz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sycon.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -87,10 +87,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::sycon( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -148,8 +148,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::sycon( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -123,10 +123,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::syrfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
@@ -215,10 +215,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::syrfs( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -74,8 +74,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(d) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(tau) >= traits::matrix_num_columns(a)-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::sytrd( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytrf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -82,8 +82,8 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::sytrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -138,8 +138,8 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::sytrf( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sytri.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,8 +81,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::sytri( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -129,8 +129,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(ipiv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::sytri( uplo, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -90,10 +90,10 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd+1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::tbcon( norm, uplo, diag, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), rcond,
@@ -151,10 +151,10 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd+1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::tbcon( norm, uplo, diag, n, kd, traits::matrix_storage(ab),
                 traits::leading_dimension(ab), rcond,

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -117,10 +117,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::tbrfs( uplo, trans, diag, n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
@@ -200,10 +200,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::tbrfs( uplo, trans, diag, n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -109,8 +109,8 @@
         assert( traits::leading_dimension(s) >= std::max(1,n) );
         assert( traits::leading_dimension(p) >= std::max(1,n) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::tgevc( side, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(s), traits::leading_dimension(s),
@@ -179,10 +179,10 @@
         assert( traits::leading_dimension(s) >= std::max(1,n) );
         assert( traits::leading_dimension(p) >= std::max(1,n) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::tgevc( side, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(s), traits::leading_dimension(s),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -102,8 +102,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::tgexc( wantq, wantz, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -144,10 +144,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::vector_size(alphar) >= n );
         assert( traits::vector_size(alphai) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::tgsen( ijob, wantq, wantz, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -257,10 +257,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::vector_size(alpha) >= n );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::tgsen( ijob, wantq, wantz, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsja.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -140,8 +140,8 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(b) ));
 #endif
         detail::tgsja( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b), k,
@@ -233,8 +233,8 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(b) ));
 #endif
         detail::tgsja( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_rows(b), traits::matrix_num_columns(b), k,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsna.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -122,10 +122,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::tgsna( job, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -224,10 +224,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::tgsna( job, howmny, traits::vector_storage(select), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tgsyl.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -125,10 +125,10 @@
                 MatrixF >::value_type >::value) );
 #ifndef NDEBUG
         assert( trans == 'N' || trans == 'T' );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( m, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( m, n ));
 #endif
         detail::tgsyl( trans, ijob, m, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),
@@ -221,10 +221,10 @@
                 MatrixF >::value_type >::value) );
 #ifndef NDEBUG
         assert( trans == 'N' || trans == 'C' );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( m, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( m, n ));
 #endif
         detail::tgsyl( trans, ijob, m, n, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -111,10 +111,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::tprfs( uplo, trans, diag, n, traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::matrix_storage(b),
@@ -191,10 +191,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::tprfs( uplo, trans, diag, n, traits::matrix_num_columns(x),
                 traits::matrix_storage(ap), traits::matrix_storage(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -87,10 +87,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::trcon( norm, uplo, diag, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -148,10 +148,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::trcon( norm, uplo, diag, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trevc.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -102,8 +102,8 @@
         assert( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(t) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(t) ));
 #endif
         detail::trevc( side, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
@@ -169,10 +169,10 @@
         assert( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(t) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(t) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(t) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(t) ));
 #endif
         detail::trevc( side, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trexc.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,8 +88,8 @@
                 traits::matrix_num_columns(t)) );
         assert( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(t)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(t) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(t) ));
 #endif
         detail::trexc( compq, traits::matrix_num_columns(t),
                 traits::matrix_storage(t), traits::leading_dimension(t),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -119,10 +119,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::trrfs( uplo, trans, diag, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
@@ -204,10 +204,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::trrfs( uplo, trans, diag, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsen.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,8 +81,8 @@
         assert( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(t) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::trsen( job, compq, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trsna.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -114,10 +114,10 @@
         assert( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( $CALL_MIN_SIZE ));
 #endif
         detail::trsna( job, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),
@@ -195,10 +195,10 @@
         assert( traits::leading_dimension(t) >= std::max(1,
                 traits::matrix_num_columns(t)) );
         assert( mm >= m );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( $CALL_MIN_SIZE ));
 #endif
         detail::trsna( job, howmny, traits::vector_storage(select),
                 traits::matrix_num_columns(t), traits::matrix_storage(t),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tzrzf.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -86,8 +86,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::tzrzf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -144,8 +144,8 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(tau) >= traits::matrix_num_rows(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::tzrzf( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungbr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -71,8 +71,8 @@
         assert( m >= 0 );
         assert( k >= 0 );
         assert( traits::leading_dimension(a) >= m );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( m, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( m, n ));
 #endif
         detail::ungbr( vect, m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unghr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -70,8 +70,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::vector_size(tau) >= n-1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::unghr( n, ilo, ihi, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -72,8 +72,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( m )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( m ));
 #endif
         detail::unglq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -72,8 +72,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
 #endif
         detail::ungql( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -72,8 +72,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
 #endif
         detail::ungqr( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -72,8 +72,8 @@
         assert( k >= k );
         assert( traits::leading_dimension(a) >= std::max(1,m) );
         assert( traits::vector_size(tau) >= k );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( m )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( m ));
 #endif
         detail::ungrq( m, n, k, traits::matrix_storage(a),
                 traits::leading_dimension(a), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -69,8 +69,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= n );
         assert( traits::vector_size(tau) >= n-1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( side, m, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( side, m, n ));
 #endif
         detail::ungtr( traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -84,9 +84,9 @@
         assert( traits::vector_size(tau) >= std::min(?NQ,k) );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmbr( vect, side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmhr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -82,9 +82,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmhr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), ilo, ihi,

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,9 +81,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmlq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -80,9 +80,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmql( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmqr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -80,9 +80,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmqr( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,9 +81,9 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmrq( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k, traits::matrix_storage(a),

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	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,8 +81,8 @@
         assert( traits::vector_size(tau) >= k );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::unmrz( side, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), k,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unmtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -81,9 +81,9 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( side, traits::matrix_num_rows(c),
-                traits::matrix_num_columns(c) )));
+                traits::matrix_num_columns(c) ));
 #endif
         detail::unmtr( side, traits::matrix_uplo_tag(a), trans,
                 traits::matrix_num_rows(c), traits::matrix_num_columns(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upgtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,8 +77,8 @@
         assert( traits::vector_size(tau) >= traits::matrix_num_columns(q)-1 );
         assert( traits::leading_dimension(q) >= std::max(1,
                 traits::matrix_num_columns(q)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(q) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(q) ));
 #endif
         detail::upgtr( uplo, traits::matrix_num_columns(q),
                 traits::vector_storage(ap), traits::vector_storage(tau),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/upmtr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,8 +77,8 @@
         assert( traits::matrix_num_columns(c) >= 0 );
         assert( traits::leading_dimension(c) >= std::max(1,
                 traits::matrix_num_rows(c)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
 #endif
         detail::upmtr( side, uplo, trans, traits::matrix_num_rows(c),
                 traits::matrix_num_columns(c), traits::vector_storage(ap),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/cgesv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,11 +73,11 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_swork( traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
+                traits::matrix_num_columns(b) ));
 #endif
         detail::cgesv( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gbsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -143,10 +143,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::gbsvx( fact, trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),
@@ -249,10 +249,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::gbsvx( fact, trans, n, kl, ku, traits::matrix_num_columns(x),
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gees.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -111,10 +111,10 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::gees( jobvs, sort, select, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a), sdim,
@@ -198,12 +198,12 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::gees( jobvs, sort, select, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a), sdim,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geesx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -116,12 +116,12 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::geesx( jobvs, sort, select, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -228,12 +228,12 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::geesx( jobvs, sort, select, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -112,8 +112,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(wr) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobvl, jobvr, traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobvl, jobvr, traits::matrix_num_columns(a) ));
 #endif
         detail::geev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -193,10 +193,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::geev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/geevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -142,10 +142,11 @@
         assert( traits::vector_size(wi) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(rconde) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(rcondv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                sense, jobvl, jobvr, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( sense, traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( sense, jobvl, jobvr,
+                traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( sense, traits::matrix_num_columns(a) ));
 #endif
         detail::geevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -273,10 +274,10 @@
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(rconde) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(rcondv) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( sense, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( sense, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::geevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gegv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -127,8 +127,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::gegv( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -223,10 +223,10 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gegv( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gels.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -96,9 +96,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(a),
+                traits::matrix_num_columns(b) ));
 #endif
         detail::gels( trans, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -164,10 +165,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
+                traits::matrix_num_columns(b) ));
 #endif
         detail::gels( trans, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -115,10 +115,11 @@
                 traits::matrix_num_columns(a))) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                minmn, smlsiz, nlvl, traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( minmn, nlvl )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( minmn, smlsiz, nlvl,
+                traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( minmn, nlvl ));
 #endif
         detail::gelsd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -216,13 +217,13 @@
                 traits::matrix_num_columns(a))) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( minmn, traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(real_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( minmn, traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( minmn, smlsiz, nlvl,
-                traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( minmn, nlvl )));
+                traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( minmn, nlvl ));
 #endif
         detail::gelsd( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelss.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -105,9 +105,10 @@
                 traits::matrix_num_columns(a))) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(a),
+                traits::matrix_num_columns(b) ));
 #endif
         detail::gelss( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -183,12 +184,12 @@
                 traits::matrix_num_columns(a))) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
-                minmn )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( minmn )));
+                minmn ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( minmn ));
 #endif
         detail::gelss( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gelsy.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -101,9 +101,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(a),
+                traits::matrix_num_columns(b) ));
 #endif
         detail::gelsy( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -174,12 +175,12 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 std::max(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a))) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+                traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gelsy( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesdd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -109,11 +109,11 @@
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(a),
-                jobz, minmn )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( minmn )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(a), jobz, minmn ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( minmn ));
 #endif
         detail::gesdd( jobz, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -192,13 +192,13 @@
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
-                traits::matrix_num_columns(a), jobz, minmn )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( minmn, jobz )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( minmn )));
+                traits::matrix_num_columns(a), jobz, minmn ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( minmn, jobz ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( minmn ));
 #endif
         detail::gesdd( jobz, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -107,8 +107,9 @@
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(a) ));
 #endif
         detail::gesvd( jobu, jobvt, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -184,11 +185,11 @@
                 traits::matrix_num_rows(a)) );
         assert( traits::vector_size(s) >= std::min(traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
-                traits::matrix_num_columns(a), minmn )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( minmn )));
+                traits::matrix_num_columns(a), minmn ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( minmn ));
 #endif
         detail::gesvd( jobu, jobvt, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gesvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -138,10 +138,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gesvx( fact, trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),
@@ -245,10 +245,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::gesvx( fact, trans, traits::matrix_num_columns(a),
                 traits::matrix_num_columns(x), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gges.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -141,10 +141,10 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::gges( jobvsl, jobvsr, sort, selctg,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -257,12 +257,12 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::gges( jobvsl, jobvsr, sort, selctg,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggesx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -156,12 +156,12 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::ggesx( jobvsl, jobvsr, sort, selctg, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -306,14 +306,14 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a), sense )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                traits::matrix_num_columns(a), sort )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a), sense ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                traits::matrix_num_columns(a), sort ));
 #endif
         detail::ggesx( jobvsl, jobvsr, sort, selctg, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -127,8 +127,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::ggev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),
@@ -223,10 +223,10 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::ggev( jobvl, jobvr, traits::matrix_num_columns(a),
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -168,12 +168,13 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alphar) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(alphai) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                balanc, jobvl, jobvr, sense, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( sense, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                sense, traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( balanc, jobvl, jobvr, sense,
+                traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( sense, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                sense, traits::matrix_num_columns(a) ));
 #endif
         detail::ggevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),
@@ -335,14 +336,14 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(beta) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( sense, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( balanc, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( sense, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(bool()) >= min_size_bwork(
-                sense, traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( sense, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( balanc, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( sense, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(bool())) >= min_size_bwork(
+                sense, traits::matrix_num_columns(a) ));
 #endif
         detail::ggevx( balanc, jobvl, jobvr, sense,
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggglm.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -111,9 +111,9 @@
         assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
         assert( traits::vector_size(x) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(y) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a), traits::matrix_num_rows(b),
-                traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a),
+                traits::matrix_num_rows(b), traits::matrix_num_columns(b) ));
 #endif
         detail::ggglm( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -194,9 +194,9 @@
         assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
         assert( traits::vector_size(x) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(y) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(a),
-                traits::matrix_num_rows(b), traits::matrix_num_columns(b) )));
+                traits::matrix_num_rows(b), traits::matrix_num_columns(b) ));
 #endif
         detail::ggglm( traits::matrix_num_rows(b),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gglse.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -110,9 +110,9 @@
         assert( traits::vector_size(c) >= traits::matrix_num_rows(a) );
         assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
         assert( traits::vector_size(x) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_rows(a), traits::matrix_num_columns(b),
-                traits::matrix_num_rows(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_rows(a),
+                traits::matrix_num_columns(b), traits::matrix_num_rows(b) ));
 #endif
         detail::gglse( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b),
@@ -192,9 +192,9 @@
         assert( traits::vector_size(c) >= traits::matrix_num_rows(a) );
         assert( traits::vector_size(d) >= traits::matrix_num_rows(b) );
         assert( traits::vector_size(x) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_rows(a),
-                traits::matrix_num_columns(b), traits::matrix_num_rows(b) )));
+                traits::matrix_num_columns(b), traits::matrix_num_rows(b) ));
 #endif
         detail::gglse( traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ggsvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -139,11 +139,11 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(b), traits::matrix_num_rows(a),
-                traits::matrix_num_rows(b) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(b) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(b),
+                traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(b) ));
 #endif
         detail::ggsvd( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b), k,
@@ -239,13 +239,13 @@
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_rows(b)) );
         assert( traits::vector_size(alpha) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
                 min_size_work( traits::matrix_num_columns(b),
-                traits::matrix_num_rows(a), traits::matrix_num_rows(b) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(b) )));
+                traits::matrix_num_rows(a), traits::matrix_num_rows(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(b) ));
 #endif
         detail::ggsvd( jobu, jobv, jobq, traits::matrix_num_rows(a),
                 traits::matrix_num_columns(b), traits::matrix_num_rows(b), k,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gtsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -151,10 +151,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::gtsvx( fact, trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),
@@ -265,10 +265,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(b) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::gtsvx( fact, trans, n, traits::matrix_num_columns(b),
                 traits::vector_storage(dl), traits::vector_storage(d),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,10 +73,10 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hbev( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -78,12 +78,12 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( jobz, n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::hbevd( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -93,12 +93,12 @@
         assert( traits::leading_dimension(ab) >= kd );
         assert( traits::leading_dimension(q) >= std::max(1,n) );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::hbevx( jobz, range, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -83,10 +83,10 @@
         assert( kb >= 0 );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hbgv( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,12 +88,12 @@
         assert( kb >= 0 );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( jobz, n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::hbgvd( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hbgvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -100,12 +100,12 @@
         assert( kb >= 0 );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::hbgvx( jobz, range, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -69,10 +69,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::heev( jobz, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,12 +73,12 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( jobz, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( jobz, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( jobz, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( jobz, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, traits::matrix_num_columns(a) ));
 #endif
         detail::heevd( jobz, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -90,12 +90,12 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(isuppz) >= 2*std::max(1,m) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::heevr( jobz, range, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/heevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -87,12 +87,12 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::heevx( jobz, range, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -76,10 +76,10 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hegv( itype, jobz, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -78,12 +78,12 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( jobz, n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::hegvd( itype, jobz, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hegvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -96,12 +96,12 @@
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::hegvx( itype, jobz, range, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -75,8 +75,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work(  )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work(  ));
 #endif
         detail::hesv( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hesvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -101,10 +101,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::hesvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -71,10 +71,10 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hpev( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -74,12 +74,12 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( jobz, n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::hpevd( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -80,12 +80,12 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::hpevx( jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -75,10 +75,10 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hpgv( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -82,12 +82,12 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( jobz, n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::hpgvd( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -89,12 +89,12 @@
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::hpgvx( itype, jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp), vl,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -92,10 +92,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::hpsvx( fact, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_num_columns(x), traits::matrix_storage(ap),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -104,10 +104,11 @@
         assert( traits::matrix_num_columns(b) >= 1 );
         assert( traits::vector_size(e) >= n-1 );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n, smlsiz, nlvl, traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n, nlvl )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n, smlsiz, nlvl,
+                traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n, nlvl ));
 #endif
         detail::lalsd( uplo, smlsiz, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),
@@ -185,13 +186,13 @@
         assert( traits::matrix_num_columns(b) >= 1 );
         assert( traits::vector_size(e) >= n-1 );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n, traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(real_type()) >=
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n, traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(real_type())) >=
                 min_size_rwork( n, smlsiz, nlvl,
-                traits::matrix_num_columns(b) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n, nlvl )));
+                traits::matrix_num_columns(b) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n, nlvl ));
 #endif
         detail::lalsd( uplo, smlsiz, n, traits::matrix_num_columns(b),
                 traits::vector_storage(d), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/pbsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -132,10 +132,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::pbsvx( fact, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),
@@ -230,10 +230,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::pbsvx( fact, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_num_columns(x), traits::matrix_storage(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/posvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -132,10 +132,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::posvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
@@ -232,10 +232,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::posvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ppsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -124,10 +124,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(ap) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(ap) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(ap) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(ap) ));
 #endif
         detail::ppsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),
@@ -219,10 +219,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(ap) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(ap) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(ap) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(ap) ));
 #endif
         detail::ppsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/ptsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -124,8 +124,8 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::ptsvx( fact, n, traits::matrix_num_columns(x),
                 traits::vector_storage(d), traits::vector_storage(e),
@@ -210,10 +210,10 @@
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::leading_dimension(x) >= std::max(1,n) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( n )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( n )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( n ));
 #endif
         detail::ptsvx( fact, n, traits::matrix_num_columns(x),
                 traits::vector_storage(d), traits::vector_storage(e),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -72,8 +72,8 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::sbev( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,10 +77,10 @@
         assert( n >= 0 );
         assert( kd >= 0 );
         assert( traits::leading_dimension(ab) >= kd );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::sbevd( jobz, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -92,10 +92,10 @@
         assert( traits::leading_dimension(ab) >= kd );
         assert( traits::leading_dimension(q) >= std::max(1,n) );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::sbevx( jobz, range, traits::matrix_uplo_tag(ab), n, kd,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -80,8 +80,8 @@
         assert( kb >= 0 );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::sbgv( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -84,10 +84,10 @@
         assert( kb >= 0 );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::sbgvd( jobz, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sbgvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -97,10 +97,10 @@
         assert( kb >= 0 );
         assert( traits::leading_dimension(ab) >= ka+1 );
         assert( traits::leading_dimension(bb) >= kb+1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::sbgvx( jobz, range, traits::matrix_uplo_tag(ab), n, ka, kb,
                 traits::matrix_storage(ab), traits::leading_dimension(ab),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sgesv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -70,11 +70,11 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                $CALL_MIN_SIZE )));
-        assert( traits::vector_size(work.select(real_type()) >=
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( $CALL_MIN_SIZE ));
+        assert( traits::vector_size(work.select(real_type())) >=
                 min_size_swork( traits::matrix_num_columns(a),
-                traits::matrix_num_columns(b) )));
+                traits::matrix_num_columns(b) ));
 #endif
         detail::sgesv( traits::matrix_num_columns(a),
                 traits::matrix_num_columns(b), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -68,8 +68,8 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::spev( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,10 +73,10 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::spevd( jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::vector_storage(w),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -79,10 +79,10 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::spevx( jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -73,8 +73,8 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::spgv( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -79,10 +79,10 @@
         assert( traits::matrix_uplo_tag(ap) == 'U' ||
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::spgvd( itype, jobz, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -85,10 +85,10 @@
                 traits::matrix_uplo_tag(ap) == 'L' );
         assert( n >= 0 );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::spgvx( itype, jobz, range, traits::matrix_uplo_tag(ap), n,
                 traits::matrix_storage(ap), traits::matrix_storage(bp), vl,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spsvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -120,10 +120,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(ap) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(ap) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(ap) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(ap) ));
 #endif
         detail::spsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),
@@ -211,10 +211,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(ap)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(ap) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(ap) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(ap) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(ap) ));
 #endif
         detail::spsvx( fact, traits::matrix_uplo_tag(ap),
                 traits::matrix_num_columns(ap), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -66,8 +66,8 @@
         assert( jobz == 'N' || jobz == 'V' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::stev( jobz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -71,10 +71,10 @@
         assert( jobz == 'N' || jobz == 'V' );
         assert( n >= 0 );
         assert( traits::vector_size(e) >= n-1 );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::stevd( jobz, n, traits::vector_storage(d),
                 traits::vector_storage(e), traits::matrix_storage(z),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -86,10 +86,10 @@
         assert( traits::vector_size(e) >= std::max(1,n-1) );
         assert( traits::vector_size(w) >= n );
         assert( traits::vector_size(isuppz) >= 2*std::max(1,m) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::stevr( jobz, range, n, traits::vector_storage(d),
                 traits::vector_storage(e), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/stevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -84,10 +84,10 @@
         assert( traits::vector_size(d) >= n );
         assert( traits::vector_size(e) >= std::max(1,n-1) );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::stevx( jobz, range, n, traits::vector_storage(d),
                 traits::vector_storage(e), vl, vu, il, iu, abstol, m,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syev.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -66,8 +66,8 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
 #endif
         detail::syev( jobz, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -71,10 +71,10 @@
         assert( traits::matrix_num_columns(a) >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, traits::matrix_num_columns(a) ));
 #endif
         detail::syevd( jobz, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevr.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -88,10 +88,10 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
         assert( traits::vector_size(isuppz) >= 2*std::max(1,m) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::syevr( jobz, range, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/syevx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -84,10 +84,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(w) >= traits::matrix_num_columns(a) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::syevx( jobz, range, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_storage(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -75,8 +75,8 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
 #endif
         detail::sygv( itype, jobz, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvd.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -77,10 +77,10 @@
         assert( n >= 0 );
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                jobz, n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( jobz, n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( jobz, n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( jobz, n ));
 #endif
         detail::sygvd( itype, jobz, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sygvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -93,10 +93,10 @@
         assert( traits::leading_dimension(a) >= std::max(1,n) );
         assert( traits::leading_dimension(b) >= std::max(1,n) );
         assert( traits::vector_size(w) >= n );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                n )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( n )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( n ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( n ));
 #endif
         detail::sygvx( itype, jobz, range, traits::matrix_uplo_tag(a), n,
                 traits::matrix_storage(a), traits::leading_dimension(a),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysv.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -96,8 +96,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_work(  )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work(  ));
 #endif
         detail::sysv( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),
@@ -160,8 +160,8 @@
                 traits::matrix_num_columns(a)) );
         assert( traits::leading_dimension(b) >= std::max(1,
                 traits::matrix_num_columns(a)) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work(  )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work(  ));
 #endif
         detail::sysv( traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(b),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp	(original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/sysvx.hpp	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -131,10 +131,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(real_type()) >= min_size_work(
-                traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(integer_t()) >=
-                min_size_iwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(integer_t())) >=
+                min_size_iwork( traits::matrix_num_columns(a) ));
 #endif
         detail::sysvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),
@@ -242,10 +242,10 @@
         assert( traits::leading_dimension(x) >= std::max(1,
                 traits::matrix_num_columns(a)) );
         assert( traits::vector_size(berr) >= traits::matrix_num_columns(x) );
-        assert( traits::vector_size(work.select(value_type()) >=
-                min_size_work( traits::matrix_num_columns(a) )));
-        assert( traits::vector_size(work.select(real_type()) >=
-                min_size_rwork( traits::matrix_num_columns(a) )));
+        assert( traits::vector_size(work.select(value_type())) >=
+                min_size_work( traits::matrix_num_columns(a) ));
+        assert( traits::vector_size(work.select(real_type())) >=
+                min_size_rwork( traits::matrix_num_columns(a) ));
 #endif
         detail::sysvx( fact, traits::matrix_uplo_tag(a),
                 traits::matrix_num_columns(a), traits::matrix_num_columns(x),

Modified: sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py
==============================================================================
--- sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py	(original)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py	2009-03-08 13:48:57 EDT (Sun, 08 Mar 2009)
@@ -277,8 +277,8 @@
     min_workspace_call = min_workspace_call_type( name, properties, arg_map )
     if min_workspace_call == None:
       min_workspace_call = '$CALL_MIN_SIZE'
-    result = 'assert( traits::vector_size(work.select(' + workspace_type( name, properties ) + '()) >= ' + \
-             'min_size_' + name.lower() + '( ' + min_workspace_call + ' )));'
+    result = 'assert( traits::vector_size(work.select(' + workspace_type( name, properties ) + '())) >= ' + \
+             'min_size_' + name.lower() + '( ' + min_workspace_call + ' ));'
 
   # assert_size is vector-type specific
   elif properties.has_key( 'assert_size' ):