Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r58581 - in sandbox/numeric_bindings/boost/numeric/bindings/blas: level1 level2 level3
From: rutger_at_[hidden]
Date: 2009-12-30 04:33:08

Next message: thomas.klimpel_at_[hidden]: "[Boost-commit] svn:boost r58582 - sandbox/numeric_bindings-v1"
Previous message: rutger_at_[hidden]: "[Boost-commit] svn:boost r58580 - in sandbox/numeric_bindings/libs/numeric/bindings/tools: . templates"

Author: rutger
Date: 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
New Revision: 58581
URL: http://svn.boost.org/trac/boost/changeset/58581

Log:
Sync of current BLAS bindings

Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp | 52 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp | 120 ++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp | 114 ++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp | 52 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp | 66 ++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp | 66 ++----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp | 52 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp | 52 ++---
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp | 332 ++-------------------------------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp | 93 +++-----
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp | 396 ++-------------------------------------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp | 102 ++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp | 27 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp | 116 ++++------
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp | 52 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp | 52 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp | 26 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp | 54 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp | 28 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp | 30 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp | 30 +-
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp | 52 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp | 54 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp | 54 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp | 56 ++--
   sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp | 56 ++--
   48 files changed, 1068 insertions(+), 1896 deletions(-)

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ASUM_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,73 +56,63 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline float asum( Order, const std::ptrdiff_t n, const float* x,
+inline float asum( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx ) {
- return cblas_sasum( cblas_option< Order >::value, n, x, incx );
+ return cblas_sasum( n, x, incx );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double asum( Order, const std::ptrdiff_t n, const double* x,
+inline double asum( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx ) {
- return cblas_dasum( cblas_option< Order >::value, n, x, incx );
+ return cblas_dasum( n, x, incx );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline float asum( Order, const std::ptrdiff_t n, const float* x,
+inline float asum( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasSasum( n, x, incx );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double asum( Order, const std::ptrdiff_t n, const double* x,
+inline double asum( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasDasum( n, x, incx );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline float asum( Order, const std::ptrdiff_t n, const float* x,
+inline float asum( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_SASUM( &n, x, &incx );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline double asum( Order, const std::ptrdiff_t n, const double* x,
+inline double asum( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_DASUM( &n, x, &incx );
}

@@ -149,7 +138,6 @@
     //
     template< typename VectorX >
     static return_type invoke( const VectorX& x ) {
-
         return detail::asum( size(x), begin_value(x), stride(x) );
     }
};

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_AXPY_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,155 +56,129 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const float a,
- const float* x, const std::ptrdiff_t incx, float* y,
- const std::ptrdiff_t incy ) {
- cblas_saxpy( cblas_option< Order >::value, n, a, x, incx, y, incy );
+inline void axpy( const std::ptrdiff_t n, const float a, const float* x,
+ const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
+ cblas_saxpy( n, a, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const double a,
- const double* x, const std::ptrdiff_t incx, double* y,
- const std::ptrdiff_t incy ) {
- cblas_daxpy( cblas_option< Order >::value, n, a, x, incx, y, incy );
+inline void axpy( const std::ptrdiff_t n, const double a, const double* x,
+ const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+ cblas_daxpy( n, a, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const std::complex<float> a,
+inline void axpy( const std::ptrdiff_t n, const std::complex<float> a,
         const std::complex<float>* x, const std::ptrdiff_t incx,
         std::complex<float>* y, const std::ptrdiff_t incy ) {
- cblas_caxpy( cblas_option< Order >::value, n, &a, x, incx, y, incy );
+ cblas_caxpy( n, &a, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const std::complex<double> a,
+inline void axpy( const std::ptrdiff_t n, const std::complex<double> a,
         const std::complex<double>* x, const std::ptrdiff_t incx,
         std::complex<double>* y, const std::ptrdiff_t incy ) {
- cblas_zaxpy( cblas_option< Order >::value, n, &a, x, incx, y, incy );
+ cblas_zaxpy( n, &a, x, incx, y, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const float a,
- const float* x, const std::ptrdiff_t incx, float* y,
- const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void axpy( const std::ptrdiff_t n, const float a, const float* x,
+ const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
     cublasSaxpy( n, a, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const double a,
- const double* x, const std::ptrdiff_t incx, double* y,
- const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void axpy( const std::ptrdiff_t n, const double a, const double* x,
+ const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
     cublasDaxpy( n, a, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const std::complex<float> a,
+inline void axpy( const std::ptrdiff_t n, const std::complex<float> a,
         const std::complex<float>* x, const std::ptrdiff_t incx,
         std::complex<float>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasCaxpy( n, a, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const std::complex<double> a,
+inline void axpy( const std::ptrdiff_t n, const std::complex<double> a,
         const std::complex<double>* x, const std::ptrdiff_t incx,
         std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     // NOT FOUND();
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const float a,
- const float* x, const std::ptrdiff_t incx, float* y,
- const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void axpy( const std::ptrdiff_t n, const float a, const float* x,
+ const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
     BLAS_SAXPY( &n, &a, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const double a,
- const double* x, const std::ptrdiff_t incx, double* y,
- const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void axpy( const std::ptrdiff_t n, const double a, const double* x,
+ const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
     BLAS_DAXPY( &n, &a, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const std::complex<float> a,
+inline void axpy( const std::ptrdiff_t n, const std::complex<float> a,
         const std::complex<float>* x, const std::ptrdiff_t incx,
         std::complex<float>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_CAXPY( &n, &a, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void axpy( Order, const std::ptrdiff_t n, const std::complex<double> a,
+inline void axpy( const std::ptrdiff_t n, const std::complex<double> a,
         const std::complex<double>* x, const std::ptrdiff_t incx,
         std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_ZAXPY( &n, &a, x, &incx, y, &incy );
}

@@ -236,7 +209,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
-
         detail::axpy( size(x), a, begin_value(x), stride(x),
                 begin_value(y), stride(y) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_COPY_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,149 +56,129 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const float* x,
+inline void copy( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
- cblas_scopy( cblas_option< Order >::value, n, x, incx, y, incy );
+ cblas_scopy( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const double* x,
+inline void copy( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
- cblas_dcopy( cblas_option< Order >::value, n, x, incx, y, incy );
+ cblas_dcopy( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void copy( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- cblas_ccopy( cblas_option< Order >::value, n, x, incx, y, incy );
+ cblas_ccopy( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
- cblas_zcopy( cblas_option< Order >::value, n, x, incx, y, incy );
+inline void copy( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
+ cblas_zcopy( n, x, incx, y, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const float* x,
+inline void copy( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasScopy( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const double* x,
+inline void copy( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasDcopy( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void copy( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasCcopy( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void copy( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
     // NOT FOUND();
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const float* x,
+inline void copy( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_SCOPY( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const double* x,
+inline void copy( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_DCOPY( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void copy( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_CCOPY( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void copy( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void copy( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
     BLAS_ZCOPY( &n, x, &incx, y, &incy );
}

@@ -229,7 +208,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
-
         detail::copy( size(x), begin_value(x), stride(x),
                 begin_value(y), stride(y) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOT_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,79 +56,69 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline float dot( Order, const std::ptrdiff_t n, const float* x,
+inline float dot( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, const float* y,
         const std::ptrdiff_t incy ) {
- return cblas_sdot( cblas_option< Order >::value, n, x, incx, y, incy );
+ return cblas_sdot( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double dot( Order, const std::ptrdiff_t n, const double* x,
+inline double dot( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, const double* y,
         const std::ptrdiff_t incy ) {
- return cblas_ddot( cblas_option< Order >::value, n, x, incx, y, incy );
+ return cblas_ddot( n, x, incx, y, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline float dot( Order, const std::ptrdiff_t n, const float* x,
+inline float dot( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, const float* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasSdot( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double dot( Order, const std::ptrdiff_t n, const double* x,
+inline double dot( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, const double* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasDdot( n, x, incx, y, incy );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline float dot( Order, const std::ptrdiff_t n, const float* x,
+inline float dot( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, const float* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_SDOT( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline double dot( Order, const std::ptrdiff_t n, const double* x,
+inline double dot( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, const double* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_DDOT( &n, x, &incx, y, &incy );
}

@@ -158,7 +147,6 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
-
         return detail::dot( size(x), begin_value(x), stride(x),
                 begin_value(y), stride(y) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOTC_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,81 +56,69 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void dotc( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void dotc( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, const std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- return cblas_cdotc_sub( cblas_option< Order >::value, n, x, incx, y,
- incy );
+ return cblas_cdotc_sub( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void dotc( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double>* y, const std::ptrdiff_t incy ) {
- return cblas_zdotc_sub( cblas_option< Order >::value, n, x, incx, y,
- incy );
+inline void dotc( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, const std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
+ return cblas_zdotc_sub( n, x, incx, y, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void dotc( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void dotc( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, const std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasCdotc( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void dotc( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void dotc( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, const std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
     return // NOT FOUND();
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void dotc( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void dotc( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, const std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_CDOTC( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void dotc( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void dotc( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, const std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
     return BLAS_ZDOTC( &n, x, &incx, y, &incy );
}

@@ -160,7 +147,6 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
-
         return detail::dotc( size(x), begin_value(x), stride(x),
                 begin_value(y), stride(y) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOTU_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,81 +56,69 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void dotu( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void dotu( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, const std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- return cblas_cdotu_sub( cblas_option< Order >::value, n, x, incx, y,
- incy );
+ return cblas_cdotu_sub( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void dotu( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double>* y, const std::ptrdiff_t incy ) {
- return cblas_zdotu_sub( cblas_option< Order >::value, n, x, incx, y,
- incy );
+inline void dotu( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, const std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
+ return cblas_zdotu_sub( n, x, incx, y, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void dotu( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void dotu( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, const std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasCdotu( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void dotu( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void dotu( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, const std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
     return cublasZdotu( n, x, incx, y, incy );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void dotu( Order, const std::ptrdiff_t n, const std::complex<float>* x,
+inline void dotu( const std::ptrdiff_t n, const std::complex<float>* x,
         const std::ptrdiff_t incx, const std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_CDOTU( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void dotu( Order, const std::ptrdiff_t n,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double>* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void dotu( const std::ptrdiff_t n, const std::complex<double>* x,
+ const std::ptrdiff_t incx, const std::complex<double>* y,
+ const std::ptrdiff_t incy ) {
     return BLAS_ZDOTU( &n, x, &incx, y, &incy );
}

@@ -160,7 +147,6 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
-
         return detail::dotu( size(x), begin_value(x), stride(x),
                 begin_value(y), stride(y) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_NRM2_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,73 +56,63 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline float nrm2( Order, const std::ptrdiff_t n, const float* x,
+inline float nrm2( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx ) {
- return cblas_snrm2( cblas_option< Order >::value, n, x, incx );
+ return cblas_snrm2( n, x, incx );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double nrm2( Order, const std::ptrdiff_t n, const double* x,
+inline double nrm2( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx ) {
- return cblas_dnrm2( cblas_option< Order >::value, n, x, incx );
+ return cblas_dnrm2( n, x, incx );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline float nrm2( Order, const std::ptrdiff_t n, const float* x,
+inline float nrm2( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasSnrm2( n, x, incx );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double nrm2( Order, const std::ptrdiff_t n, const double* x,
+inline double nrm2( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return cublasDnrm2( n, x, incx );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline float nrm2( Order, const std::ptrdiff_t n, const float* x,
+inline float nrm2( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_SNRM2( &n, x, &incx );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline double nrm2( Order, const std::ptrdiff_t n, const double* x,
+inline double nrm2( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_DNRM2( &n, x, &incx );
}

@@ -149,7 +138,6 @@
     //
     template< typename VectorX >
     static return_type invoke( const VectorX& x ) {
-
         return detail::nrm2( size(x), begin_value(x), stride(x) );
     }
};

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROT_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,79 +56,69 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rot( Order, const std::ptrdiff_t n, const float* x,
+inline void rot( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy,
         const float c, const float s ) {
- cblas_srot( cblas_option< Order >::value, n, x, incx, y, incy, c, s );
+ cblas_srot( n, x, incx, y, incy, c, s );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rot( Order, const std::ptrdiff_t n, const double* x,
+inline void rot( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
         const double c, const double s ) {
- cblas_drot( cblas_option< Order >::value, n, x, incx, y, incy, c, s );
+ cblas_drot( n, x, incx, y, incy, c, s );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rot( Order, const std::ptrdiff_t n, const float* x,
+inline void rot( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy,
         const float c, const float s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasSrot( n, x, incx, y, incy, c, s );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rot( Order, const std::ptrdiff_t n, const double* x,
+inline void rot( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
         const double c, const double s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasDrot( n, x, incx, y, incy, c, s );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void rot( Order, const std::ptrdiff_t n, const float* x,
+inline void rot( const std::ptrdiff_t n, const float* x,
         const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy,
         const float c, const float s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_SROT( &n, x, &incx, y, &incy, &c, &s );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void rot( Order, const std::ptrdiff_t n, const double* x,
+inline void rot( const std::ptrdiff_t n, const double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
         const double c, const double s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_DROT( &n, x, &incx, y, &incy, &c, &s );
}

@@ -160,7 +149,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
-
         detail::rot( size(x), begin_value(x), stride(x),
                 begin_value(y), stride(y), c, s );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotg.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTG_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,67 +56,57 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rotg( Order, float& a, float& b, float& c, float& s ) {
- cblas_srotg( cblas_option< Order >::value, &a, &b, &c, &s );
+inline void rotg( float& a, float& b, float& c, float& s ) {
+ cblas_srotg( &a, &b, &c, &s );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rotg( Order, double& a, double& b, double& c, double& s ) {
- cblas_drotg( cblas_option< Order >::value, &a, &b, &c, &s );
+inline void rotg( double& a, double& b, double& c, double& s ) {
+ cblas_drotg( &a, &b, &c, &s );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rotg( Order, float& a, float& b, float& c, float& s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void rotg( float& a, float& b, float& c, float& s ) {
     cublasSrotg( &a, &b, &c, &s );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rotg( Order, double& a, double& b, double& c, double& s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void rotg( double& a, double& b, double& c, double& s ) {
     cublasDrotg( &a, &b, &c, &s );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void rotg( Order, float& a, float& b, float& c, float& s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void rotg( float& a, float& b, float& c, float& s ) {
     BLAS_SROTG( &a, &b, &c, &s );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void rotg( Order, double& a, double& b, double& c, double& s ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void rotg( double& a, double& b, double& c, double& s ) {
     BLAS_DROTG( &a, &b, &c, &s );
}

@@ -141,10 +130,8 @@
     // * Deduces the required arguments for dispatching to BLAS, and
     // * Asserts that most arguments make sense.
     //
- template< >
     static return_type invoke( real_type& a, real_type& b, real_type& c,
             real_type& s ) {
-
         detail::rotg( a, b, c, s );
     }
};
@@ -159,282 +146,11 @@

//
// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, typename remove_imaginary< typename value<
- TODO >::type >::type& c, typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, typename remove_imaginary< typename value<
- TODO >::type >::type& c, typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b, typename remove_imaginary<
- typename value< TODO >::type >::type& c, typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b, typename remove_imaginary<
- typename value< TODO >::type >::type& c, typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, const typename remove_imaginary<
- typename value< TODO >::type >::type& c, typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, const typename remove_imaginary<
- typename value< TODO >::type >::type& c, typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& c, typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& c, typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, typename remove_imaginary< typename value<
- TODO >::type >::type& c, const typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, typename remove_imaginary< typename value<
- TODO >::type >::type& c, const typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b, typename remove_imaginary<
- typename value< TODO >::type >::type& c,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b, typename remove_imaginary<
- typename value< TODO >::type >::type& c,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, const typename remove_imaginary<
- typename value< TODO >::type >::type& c,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, typename remove_imaginary< typename value<
- TODO >::type >::type& b, const typename remove_imaginary<
- typename value< TODO >::type >::type& c,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& c, const typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
-}
-
-//
-// Overloaded function for rotg. Its overload differs for
-// * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
- // * const typename remove_imaginary< typename value< TODO >::type >::type&
-//
-template< >
-inline typename rotg_impl< typename value< TODO >::type >::return_type
-rotg( const typename remove_imaginary< typename value<
- TODO >::type >::type& a, const typename remove_imaginary<
- typename value< TODO >::type >::type& b,
- const typename remove_imaginary< typename value<
- TODO >::type >::type& c, const typename remove_imaginary<
- typename value< TODO >::type >::type& s ) {
- rotg_impl< typename value< TODO >::type >::invoke( a, b, c, s );
+template< typename Value >
+inline typename rotg_impl< Value >::return_type
+rotg( Value& a, Value& b, Value& c, Value& s ) {
+ rotg_impl< Value >::invoke( a, b, c, s );
}

} // namespace blas

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTM_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,79 +56,66 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rotm( Order, const std::ptrdiff_t n, float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy,
- float* param ) {
- cblas_srotm( cblas_option< Order >::value, n, x, incx, y, incy, param );
+inline void rotm( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
+ float* y, const std::ptrdiff_t incy, float* param ) {
+ cblas_srotm( n, x, incx, y, incy, param );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rotm( Order, const std::ptrdiff_t n, double* x,
+inline void rotm( const std::ptrdiff_t n, double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
         double* param ) {
- cblas_drotm( cblas_option< Order >::value, n, x, incx, y, incy, param );
+ cblas_drotm( n, x, incx, y, incy, param );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rotm( Order, const std::ptrdiff_t n, float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy,
- float* param ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void rotm( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
+ float* y, const std::ptrdiff_t incy, float* param ) {
     cublasSrotm( n, x, incx, y, incy, param );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rotm( Order, const std::ptrdiff_t n, double* x,
+inline void rotm( const std::ptrdiff_t n, double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
         double* param ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasDrotm( n, x, incx, y, incy, param );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void rotm( Order, const std::ptrdiff_t n, float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy,
- float* param ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void rotm( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
+ float* y, const std::ptrdiff_t incy, float* param ) {
     BLAS_SROTM( &n, x, &incx, y, &incy, param );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void rotm( Order, const std::ptrdiff_t n, double* x,
+inline void rotm( const std::ptrdiff_t n, double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
         double* param ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_DROTM( &n, x, &incx, y, &incy, param );
}

@@ -166,7 +152,6 @@
         BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorPARAM >::value ) );
-
         detail::rotm( n, begin_value(x), incx, begin_value(y), incy,
                 begin_value(param) );
     }
@@ -183,8 +168,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * VectorX&
- // * VectorY&
- // * VectorPARAM&
+// * VectorY&
+// * VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -197,8 +182,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * const VectorX&
- // * VectorY&
- // * VectorPARAM&
+// * VectorY&
+// * VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -212,8 +197,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * VectorX&
- // * const VectorY&
- // * VectorPARAM&
+// * const VectorY&
+// * VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -226,8 +211,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * const VectorX&
- // * const VectorY&
- // * VectorPARAM&
+// * const VectorY&
+// * VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -241,8 +226,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * VectorX&
- // * VectorY&
- // * const VectorPARAM&
+// * VectorY&
+// * const VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -255,8 +240,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * const VectorX&
- // * VectorY&
- // * const VectorPARAM&
+// * VectorY&
+// * const VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -270,8 +255,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * VectorX&
- // * const VectorY&
- // * const VectorPARAM&
+// * const VectorY&
+// * const VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
@@ -285,8 +270,8 @@
//
// Overloaded function for rotm. Its overload differs for
// * const VectorX&
- // * const VectorY&
- // * const VectorPARAM&
+// * const VectorY&
+// * const VectorPARAM&
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTMG_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,73 +56,63 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rotmg( Order, float& d1, float& d2, float& x1, const float y1,
+inline void rotmg( float& d1, float& d2, float& x1, const float y1,
         float* sparam ) {
- cblas_srotmg( cblas_option< Order >::value, &d1, &d2, &x1, &y1, sparam );
+ cblas_srotmg( &d1, &d2, &x1, &y1, sparam );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rotmg( Order, double& d1, double& d2, double& x1, const double y1,
+inline void rotmg( double& d1, double& d2, double& x1, const double y1,
         double* dparam ) {
- cblas_drotmg( cblas_option< Order >::value, &d1, &d2, &x1, &y1, dparam );
+ cblas_drotmg( &d1, &d2, &x1, &y1, dparam );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void rotmg( Order, float& d1, float& d2, float& x1, const float y1,
+inline void rotmg( float& d1, float& d2, float& x1, const float y1,
         float* sparam ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasSrotmg( &d1, &d2, &x1, &y1, sparam );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void rotmg( Order, double& d1, double& d2, double& x1, const double y1,
+inline void rotmg( double& d1, double& d2, double& x1, const double y1,
         double* dparam ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasDrotmg( &d1, &d2, &x1, &y1, dparam );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void rotmg( Order, float& d1, float& d2, float& x1, const float y1,
+inline void rotmg( float& d1, float& d2, float& x1, const float y1,
         float* sparam ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_SROTMG( &d1, &d2, &x1, &y1, sparam );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void rotmg( Order, double& d1, double& d2, double& x1, const double y1,
+inline void rotmg( double& d1, double& d2, double& x1, const double y1,
         double* dparam ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_DROTMG( &d1, &d2, &x1, &y1, dparam );
}

@@ -151,7 +140,6 @@
     static return_type invoke( real_type& d1, real_type& d2, real_type& x1,
             const real_type y1, VectorDPARAM& dparam ) {
         BOOST_STATIC_ASSERT( (is_mutable< VectorDPARAM >::value ) );
-
         detail::rotmg( d1, d2, x1, y1, begin_value(dparam) );
     }
};
@@ -166,12 +154,7 @@

//
// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
+// * VectorDPARAM&
//
template< typename VectorDPARAM >
inline typename rotmg_impl< typename value<
@@ -189,177 +172,7 @@

//
// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
+// * const VectorDPARAM&
//
template< typename VectorDPARAM >
inline typename rotmg_impl< typename value<
@@ -375,171 +188,6 @@
             x1, y1, dparam );
}

-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * typename remove_imaginary< typename value< VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
-//
-// Overloaded function for rotmg. Its overload differs for
-// * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type&
- // * const VectorDPARAM&
-//
-template< typename VectorDPARAM >
-inline typename rotmg_impl< typename value<
- VectorDPARAM >::type >::return_type
-rotmg( const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& d1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type& d2,
- const typename remove_imaginary< typename value<
- VectorDPARAM >::type >::type& x1, const typename remove_imaginary<
- typename value< VectorDPARAM >::type >::type y1,
- const VectorDPARAM& dparam ) {
- rotmg_impl< typename value< VectorDPARAM >::type >::invoke( d1, d2,
- x1, y1, dparam );
-}
-
} // namespace blas
} // namespace bindings
} // namespace numeric

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SCAL_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,143 +56,123 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const float a, float* x,
+inline void scal( const std::ptrdiff_t n, const float a, float* x,
         const std::ptrdiff_t incx ) {
- cblas_sscal( cblas_option< Order >::value, n, a, x, incx );
+ cblas_sscal( n, a, x, incx );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const double a, double* x,
+inline void scal( const std::ptrdiff_t n, const double a, double* x,
         const std::ptrdiff_t incx ) {
- cblas_dscal( cblas_option< Order >::value, n, a, x, incx );
+ cblas_dscal( n, a, x, incx );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const std::complex<float> a,
+inline void scal( const std::ptrdiff_t n, const std::complex<float> a,
         std::complex<float>* x, const std::ptrdiff_t incx ) {
- cblas_cscal( cblas_option< Order >::value, n, &a, x, incx );
+ cblas_cscal( n, &a, x, incx );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const std::complex<double> a,
+inline void scal( const std::ptrdiff_t n, const std::complex<double> a,
         std::complex<double>* x, const std::ptrdiff_t incx ) {
- cblas_zscal( cblas_option< Order >::value, n, &a, x, incx );
+ cblas_zscal( n, &a, x, incx );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const float a, float* x,
+inline void scal( const std::ptrdiff_t n, const float a, float* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasSscal( n, a, x, incx );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const double a, double* x,
+inline void scal( const std::ptrdiff_t n, const double a, double* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasDscal( n, a, x, incx );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const std::complex<float> a,
+inline void scal( const std::ptrdiff_t n, const std::complex<float> a,
         std::complex<float>* x, const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasCscal( n, a, x, incx );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const std::complex<double> a,
+inline void scal( const std::ptrdiff_t n, const std::complex<double> a,
         std::complex<double>* x, const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasZscal( n, a, x, incx );
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const float a, float* x,
+inline void scal( const std::ptrdiff_t n, const float a, float* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_SSCAL( &n, &a, x, &incx );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const double a, double* x,
+inline void scal( const std::ptrdiff_t n, const double a, double* x,
         const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_DSCAL( &n, &a, x, &incx );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const std::complex<float> a,
+inline void scal( const std::ptrdiff_t n, const std::complex<float> a,
         std::complex<float>* x, const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_CSCAL( &n, &a, x, &incx );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void scal( Order, const std::ptrdiff_t n, const std::complex<double> a,
+inline void scal( const std::ptrdiff_t n, const std::complex<double> a,
         std::complex<double>* x, const std::ptrdiff_t incx ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_ZSCAL( &n, &a, x, &incx );
}

@@ -220,7 +199,6 @@
     template< typename VectorX >
     static return_type invoke( const value_type a, VectorX& x ) {
         BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
-
         detail::scal( size(x), a, begin_value(x), stride(x) );
     }
};

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SDOT_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,41 +56,36 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double sdot( Order, const std::ptrdiff_t n, const float* sx,
+inline double sdot( const std::ptrdiff_t n, const float* sx,
         const std::ptrdiff_t incx, const float* sy,
         const std::ptrdiff_t incy ) {
- return cblas_dsdot( cblas_option< Order >::value, n, sx, incx, sy, incy );
+ return cblas_dsdot( n, sx, incx, sy, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline double sdot( Order, const std::ptrdiff_t n, const float* sx,
+inline double sdot( const std::ptrdiff_t n, const float* sx,
         const std::ptrdiff_t incx, const float* sy,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return // NOT FOUND();
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline double sdot( Order, const std::ptrdiff_t n, const float* sx,
+inline double sdot( const std::ptrdiff_t n, const float* sx,
         const std::ptrdiff_t incx, const float* sy,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     return BLAS_DSDOT( &n, sx, &incx, sy, &incy );
}

@@ -122,7 +116,6 @@
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorSX >::type >::type, typename remove_const<
                 typename value< VectorSY >::type >::type >::value) );
-
         return detail::sdot( n, begin_value(sx), incx, begin_value(sy),
                 incy );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -15,7 +15,6 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SWAP_HPP

#include <boost/assert.hpp>
-#include <boost/numeric/bindings/is_column_major.hpp>
#include <boost/numeric/bindings/is_mutable.hpp>
#include <boost/numeric/bindings/remove_imaginary.hpp>
#include <boost/numeric/bindings/size.hpp>
@@ -57,149 +56,129 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
- cblas_sswap( cblas_option< Order >::value, n, x, incx, y, incy );
+inline void swap( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
+ float* y, const std::ptrdiff_t incy ) {
+ cblas_sswap( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, double* x,
+inline void swap( const std::ptrdiff_t n, double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
- cblas_dswap( cblas_option< Order >::value, n, x, incx, y, incy );
+ cblas_dswap( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, std::complex<float>* x,
+inline void swap( const std::ptrdiff_t n, std::complex<float>* x,
         const std::ptrdiff_t incx, std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- cblas_cswap( cblas_option< Order >::value, n, x, incx, y, incy );
+ cblas_cswap( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, std::complex<double>* x,
+inline void swap( const std::ptrdiff_t n, std::complex<double>* x,
         const std::ptrdiff_t incx, std::complex<double>* y,
         const std::ptrdiff_t incy ) {
- cblas_zswap( cblas_option< Order >::value, n, x, incx, y, incy );
+ cblas_zswap( n, x, incx, y, incy );
}

#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void swap( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
+ float* y, const std::ptrdiff_t incy ) {
     cublasSswap( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, double* x,
+inline void swap( const std::ptrdiff_t n, double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasDswap( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, std::complex<float>* x,
+inline void swap( const std::ptrdiff_t n, std::complex<float>* x,
         const std::ptrdiff_t incx, std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     cublasCswap( n, x, incx, y, incy );
}

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, std::complex<double>* x,
+inline void swap( const std::ptrdiff_t n, std::complex<double>* x,
         const std::ptrdiff_t incx, std::complex<double>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     // NOT FOUND();
}

#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
+inline void swap( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
+ float* y, const std::ptrdiff_t incy ) {
     BLAS_SSWAP( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, double* x,
+inline void swap( const std::ptrdiff_t n, double* x,
         const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_DSWAP( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, std::complex<float>* x,
+inline void swap( const std::ptrdiff_t n, std::complex<float>* x,
         const std::ptrdiff_t incx, std::complex<float>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_CSWAP( &n, x, &incx, y, &incy );
}

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
-template< typename Order >
-inline void swap( Order, const std::ptrdiff_t n, std::complex<double>* x,
+inline void swap( const std::ptrdiff_t n, std::complex<double>* x,
         const std::ptrdiff_t incx, std::complex<double>* y,
         const std::ptrdiff_t incy ) {
- BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
     BLAS_ZSWAP( &n, x, &incx, y, &incy );
}

@@ -230,7 +209,6 @@
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
-
         detail::swap( size(x), begin_value(x), stride(x),
                 begin_value(y), stride(y) );
     }
@@ -247,7 +225,7 @@
//
// Overloaded function for swap. Its overload differs for
// * VectorX&
- // * VectorY&
+// * VectorY&
//
template< typename VectorX, typename VectorY >
inline typename swap_impl< typename value< VectorX >::type >::return_type
@@ -258,7 +236,7 @@
//
// Overloaded function for swap. Its overload differs for
// * const VectorX&
- // * VectorY&
+// * VectorY&
//
template< typename VectorX, typename VectorY >
inline typename swap_impl< typename value< VectorX >::type >::return_type
@@ -269,7 +247,7 @@
//
// Overloaded function for swap. Its overload differs for
// * VectorX&
- // * const VectorY&
+// * const VectorY&
//
template< typename VectorX, typename VectorY >
inline typename swap_impl< typename value< VectorX >::type >::return_type
@@ -280,7 +258,7 @@
//
// Overloaded function for swap. Its overload differs for
// * const VectorX&
- // * const VectorY&
+// * const VectorY&
//
template< typename VectorX, typename VectorY >
inline typename swap_impl< typename value< VectorX >::type >::return_type

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -89,8 +89,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -106,8 +106,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -124,8 +124,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -140,8 +140,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -155,8 +155,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -173,8 +173,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -191,8 +191,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -207,8 +207,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -223,8 +223,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -241,8 +241,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename Trans >
inline void gbmv( Order, Trans, const std::ptrdiff_t m,
@@ -281,6 +281,8 @@
     static return_type invoke( const std::ptrdiff_t kl,
             const std::ptrdiff_t ku, const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ typedef typename detail::default_order< MatrixA >::type order;
+ typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -288,8 +290,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename detail::default_order< MatrixA >::type order;
- typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         detail::gbmv( order(), trans(), size_row_op(a, trans()),
                 size_column_op(a, trans()), kl, ku, alpha, begin_value(a),
                 stride_major(a), begin_value(x), stride(x), beta,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -73,8 +73,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -87,8 +87,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -103,8 +103,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -120,8 +120,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -135,8 +135,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -150,8 +150,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -167,8 +167,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -185,8 +185,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -200,8 +200,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -215,8 +215,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -232,8 +232,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename Trans >
inline void gemv( Order, Trans, const std::ptrdiff_t m,
@@ -277,6 +277,8 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ typedef typename detail::default_order< MatrixA >::type order;
+ typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -284,8 +286,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename detail::default_order< MatrixA >::type order;
- typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         detail::gemv( order(), trans(), size_row_op(a, trans()),
                 size_column_op(a, trans()), alpha, begin_value(a),
                 stride_major(a), begin_value(x), stride(x), beta,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -58,8 +58,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order >
inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order >
inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -87,8 +87,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order >
inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -101,8 +101,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order >
inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -116,8 +116,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order >
inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -130,8 +130,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order >
inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -165,6 +165,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -172,7 +173,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
         detail::ger( order(), size_row(a), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(a), stride_major(a) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -58,8 +58,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order >
inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -73,8 +73,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order >
inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -89,8 +89,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order >
inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -104,8 +104,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order >
inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -120,8 +120,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order >
inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -135,8 +135,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order >
inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -171,6 +171,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -178,7 +179,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
         detail::gerc( order(), size_row(a), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(a), stride_major(a) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -58,8 +58,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order >
inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -73,8 +73,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order >
inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -89,8 +89,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order >
inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -104,8 +104,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order >
inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -120,8 +120,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order >
inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -135,8 +135,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order >
inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
@@ -171,6 +171,7 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -178,7 +179,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
         detail::geru( order(), size_row(a), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(a), stride_major(a) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -90,8 +90,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -106,8 +106,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -122,8 +122,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -138,8 +138,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -176,6 +176,8 @@
     static return_type invoke( const std::ptrdiff_t k, const value_type alpha,
             const MatrixA& a, const VectorX& x, const value_type beta,
             VectorY& y ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -183,8 +185,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::hbmv( order(), uplo(), size_column(a), k, alpha,
                 begin_value(a), stride_major(a), begin_value(x), stride(x),
                 beta, begin_value(y), stride(y) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hemv( Order, UpLo, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hemv( Order, UpLo, const std::ptrdiff_t n,
@@ -90,8 +90,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hemv( Order, UpLo, const std::ptrdiff_t n,
@@ -106,8 +106,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hemv( Order, UpLo, const std::ptrdiff_t n,
@@ -122,8 +122,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hemv( Order, UpLo, const std::ptrdiff_t n,
@@ -138,8 +138,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hemv( Order, UpLo, const std::ptrdiff_t n,
@@ -175,6 +175,8 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -182,8 +184,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::hemv( order(), uplo(), size_column(a), alpha,
                 begin_value(a), stride_major(a), begin_value(x), stride(x),
                 beta, begin_value(y), stride(y) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void her( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void her( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -86,8 +86,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void her( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -99,8 +99,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void her( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -113,8 +113,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void her( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -126,8 +126,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void her( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -160,12 +160,12 @@
     template< typename VectorX, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::her( order(), uplo(), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(a), stride_major(a) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void her2( Order, UpLo, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void her2( Order, UpLo, const std::ptrdiff_t n,
@@ -90,8 +90,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void her2( Order, UpLo, const std::ptrdiff_t n,
@@ -106,8 +106,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void her2( Order, UpLo, const std::ptrdiff_t n,
@@ -122,8 +122,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void her2( Order, UpLo, const std::ptrdiff_t n,
@@ -138,8 +138,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void her2( Order, UpLo, const std::ptrdiff_t n,
@@ -175,6 +175,8 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -182,8 +184,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::her2( order(), uplo(), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(a), stride_major(a) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
@@ -90,8 +90,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
@@ -106,8 +106,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
@@ -122,8 +122,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
@@ -138,8 +138,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
@@ -175,6 +175,8 @@
     template< typename MatrixAP, typename VectorX, typename VectorY >
     static return_type invoke( const value_type alpha, const MatrixAP& ap,
             const VectorX& x, const value_type beta, VectorY& y ) {
+ typedef typename result_of::data_order< MatrixAP >::type order;
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -182,8 +184,6 @@
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename result_of::data_order< MatrixAP >::type order;
- typedef typename result_of::data_side< MatrixAP >::type uplo;
         detail::hpmv( order(), uplo(), size_column(ap), alpha,
                 begin_value(ap), begin_value(x), stride(x), beta,
                 begin_value(y), stride(y) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -86,8 +86,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -99,8 +99,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -113,8 +113,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -126,8 +126,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -160,12 +160,12 @@
     template< typename VectorX, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixAP& ap ) {
+ typedef typename result_of::data_order< MatrixAP >::type order;
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value ) );
- typedef typename result_of::data_order< MatrixAP >::type order;
- typedef typename result_of::data_side< MatrixAP >::type uplo;
         detail::hpr( order(), uplo(), size_column(ap), alpha,
                 begin_value(x), stride(x), begin_value(ap) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
@@ -73,8 +73,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
@@ -88,8 +88,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
@@ -102,8 +102,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
@@ -117,8 +117,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
@@ -132,8 +132,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
@@ -168,6 +168,8 @@
     template< typename VectorX, typename VectorY, typename MatrixAP >
     static return_type invoke( const value_type alpha, const VectorX& x,
             const VectorY& y, MatrixAP& ap ) {
+ typedef typename result_of::data_order< MatrixAP >::type order;
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -175,8 +177,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value ) );
- typedef typename result_of::data_order< MatrixAP >::type order;
- typedef typename result_of::data_side< MatrixAP >::type uplo;
         detail::hpr2( order(), uplo(), size_column(ap), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(ap) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -73,8 +73,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -88,8 +88,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -103,8 +103,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -118,8 +118,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -133,8 +133,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
@@ -170,6 +170,8 @@
     static return_type invoke( const std::ptrdiff_t k, const real_type alpha,
             const MatrixA& a, const VectorX& x, const real_type beta,
             VectorY& y ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -177,8 +179,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::sbmv( order(), uplo(), size_column(a), k, alpha,
                 begin_value(a), stride_major(a), begin_value(x), stride(x),
                 beta, begin_value(y), stride(y) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spmv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spmv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -86,8 +86,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spmv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -100,8 +100,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spmv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -114,8 +114,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spmv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -128,8 +128,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spmv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -163,6 +163,8 @@
     template< typename MatrixAP, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixAP& ap,
             const VectorX& x, const real_type beta, VectorY& y ) {
+ typedef typename result_of::data_order< MatrixAP >::type order;
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -170,8 +172,6 @@
                 MatrixAP >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename result_of::data_order< MatrixAP >::type order;
- typedef typename result_of::data_side< MatrixAP >::type uplo;
         detail::spmv( order(), uplo(), size_column(ap), alpha,
                 begin_value(ap), begin_value(x), stride(x), beta,
                 begin_value(y), stride(y) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -71,8 +71,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -84,8 +84,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -96,8 +96,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -109,8 +109,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -121,8 +121,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -154,12 +154,12 @@
     template< typename VectorX, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixAP& ap ) {
+ typedef typename result_of::data_order< MatrixAP >::type order;
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value ) );
- typedef typename result_of::data_order< MatrixAP >::type order;
- typedef typename result_of::data_side< MatrixAP >::type uplo;
         detail::spr( order(), uplo(), size_column(ap), alpha,
                 begin_value(x), stride(x), begin_value(ap) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -86,8 +86,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -99,8 +99,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -113,8 +113,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void spr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -127,8 +127,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void spr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -162,6 +162,8 @@
     template< typename VectorX, typename VectorY, typename MatrixAP >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixAP& ap ) {
+ typedef typename result_of::data_order< MatrixAP >::type order;
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -169,8 +171,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixAP >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value ) );
- typedef typename result_of::data_order< MatrixAP >::type order;
- typedef typename result_of::data_side< MatrixAP >::type uplo;
         detail::spr2( order(), uplo(), size_column(ap), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(ap) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void symv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -73,8 +73,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void symv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -88,8 +88,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void symv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -103,8 +103,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void symv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -118,8 +118,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void symv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -133,8 +133,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void symv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -169,6 +169,8 @@
     template< typename MatrixA, typename VectorX, typename VectorY >
     static return_type invoke( const real_type alpha, const MatrixA& a,
             const VectorX& x, const real_type beta, VectorY& y ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorX >::type >::type >::value) );
@@ -176,8 +178,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::symv( order(), uplo(), size_column(a), alpha,
                 begin_value(a), stride_major(a), begin_value(x), stride(x),
                 beta, begin_value(y), stride(y) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void syr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void syr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -86,8 +86,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void syr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -99,8 +99,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void syr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -113,8 +113,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void syr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -126,8 +126,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void syr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -160,12 +160,12 @@
     template< typename VectorX, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::syr( order(), uplo(), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(a), stride_major(a) );
     }

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void syr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -72,8 +72,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void syr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -86,8 +86,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void syr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -100,8 +100,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void syr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -114,8 +114,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void syr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
@@ -128,8 +128,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void syr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
@@ -163,6 +163,8 @@
     template< typename VectorX, typename VectorY, typename MatrixA >
     static return_type invoke( const real_type alpha, const VectorX& x,
             const VectorY& y, MatrixA& a ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 VectorX >::type >::type, typename remove_const<
                 typename value< VectorY >::type >::type >::value) );
@@ -170,8 +172,6 @@
                 VectorX >::type >::type, typename remove_const<
                 typename value< MatrixA >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value ) );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::syr2( order(), uplo(), size_column(a), alpha,
                 begin_value(x), stride(x), begin_value(y), stride(y),
                 begin_value(a), stride_major(a) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -75,8 +75,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -89,8 +89,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -104,8 +104,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -120,8 +120,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -134,8 +134,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -147,8 +147,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -162,8 +162,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -177,8 +177,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -191,8 +191,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -205,8 +205,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -220,8 +220,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -256,14 +256,14 @@
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const std::ptrdiff_t k, const MatrixA& a,
             VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
- MatrixA >::type >::type, typename remove_const<
- typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
+ BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
+ MatrixA >::type >::type, typename remove_const<
+ typename value< VectorX >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         detail::tbmv( order(), uplo(), trans(), diag(),
                 size_column_op(a, trans()), k, begin_value(a),
                 stride_major(a), begin_value(x), stride(x) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -75,8 +75,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -89,8 +89,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -104,8 +104,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -120,8 +120,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -134,8 +134,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -147,8 +147,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -162,8 +162,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -177,8 +177,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -191,8 +191,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -205,8 +205,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -220,8 +220,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -256,14 +256,14 @@
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const std::ptrdiff_t k, const MatrixA& a,
             VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
- MatrixA >::type >::type, typename remove_const<
- typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
+ BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
+ MatrixA >::type >::type, typename remove_const<
+ typename value< VectorX >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         detail::tbsv( order(), uplo(), trans(), diag(),
                 size_column_op(a, trans()), k, begin_value(a),
                 stride_major(a), begin_value(x), stride(x) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -87,8 +87,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -101,8 +101,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -116,8 +116,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -129,8 +129,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -141,8 +141,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -155,8 +155,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -169,8 +169,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -182,8 +182,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -195,8 +195,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -209,8 +209,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -243,14 +243,14 @@
     //
     template< typename MatrixAP, typename VectorX >
     static return_type invoke( const MatrixAP& ap, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
- MatrixAP >::type >::type, typename remove_const<
- typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         typedef typename detail::default_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         typedef typename result_of::trans_tag< MatrixAP, order >::type trans;
         typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
+ MatrixAP >::type >::type, typename remove_const<
+ typename value< VectorX >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         detail::tpmv( order(), uplo(), trans(), diag(),
                 size_column_op(ap, trans()), begin_value(ap), begin_value(x),
                 stride(x) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -87,8 +87,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -101,8 +101,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -116,8 +116,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -129,8 +129,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -141,8 +141,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -155,8 +155,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -169,8 +169,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -182,8 +182,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -195,8 +195,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -209,8 +209,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -243,14 +243,14 @@
     //
     template< typename MatrixAP, typename VectorX >
     static return_type invoke( const MatrixAP& ap, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
- MatrixAP >::type >::type, typename remove_const<
- typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         typedef typename detail::default_order< MatrixAP >::type order;
         typedef typename result_of::data_side< MatrixAP >::type uplo;
         typedef typename result_of::trans_tag< MatrixAP, order >::type trans;
         typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
+ MatrixAP >::type >::type, typename remove_const<
+ typename value< VectorX >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         detail::tpsv( order(), uplo(), trans(), diag(),
                 size_column_op(ap, trans()), begin_value(ap), begin_value(x),
                 stride(x) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -75,8 +75,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -89,8 +89,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -103,8 +103,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -118,8 +118,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -132,8 +132,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -145,8 +145,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -158,8 +158,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -172,8 +172,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -186,8 +186,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -200,8 +200,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -214,8 +214,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -248,14 +248,14 @@
     //
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const MatrixA& a, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
- MatrixA >::type >::type, typename remove_const<
- typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
+ BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
+ MatrixA >::type >::type, typename remove_const<
+ typename value< VectorX >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         detail::trmv( order(), uplo(), trans(), diag(),
                 size_column_op(a, trans()), begin_value(a), stride_major(a),
                 begin_value(x), stride(x) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -75,8 +75,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -89,8 +89,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -103,8 +103,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -118,8 +118,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -132,8 +132,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -146,8 +146,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -160,8 +160,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -174,8 +174,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -188,8 +188,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -202,8 +202,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -216,8 +216,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
@@ -250,14 +250,14 @@
     //
     template< typename MatrixA, typename VectorX >
     static return_type invoke( const MatrixA& a, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
- MatrixA >::type >::type, typename remove_const<
- typename value< VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         typedef typename detail::default_order< MatrixA >::type order;
         typedef typename result_of::data_side< MatrixA >::type uplo;
         typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         typedef typename result_of::diag_tag< MatrixA >::type diag;
+ BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
+ MatrixA >::type >::type, typename remove_const<
+ typename value< VectorX >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
         detail::trsv( order(), uplo(), trans(), diag(),
                 size_column_op(a, trans()), begin_value(a), stride_major(a),
                 begin_value(x), stride(x) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -75,8 +75,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -91,8 +91,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -108,8 +108,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -126,8 +126,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -142,8 +142,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -158,8 +158,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -175,8 +175,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -193,8 +193,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -209,8 +209,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -225,8 +225,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -242,8 +242,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename TransA, typename TransB >
inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
@@ -280,6 +280,9 @@
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const MatrixB& b, const value_type beta, MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixC >::type order;
+ typedef typename result_of::trans_tag< MatrixA, order >::type transa;
+ typedef typename result_of::trans_tag< MatrixB, order >::type transb;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
@@ -287,9 +290,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
- typedef typename result_of::data_order< MatrixC >::type order;
- typedef typename result_of::trans_tag< MatrixA, order >::type transa;
- typedef typename result_of::trans_tag< MatrixB, order >::type transb;
         detail::gemm( order(), transa(), transb(), size_row(c),
                 size_column(c), size_column(a), alpha, begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b), beta,

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -76,8 +76,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -94,8 +94,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -111,8 +111,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -128,8 +128,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -145,8 +145,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -184,6 +184,8 @@
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
             MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
@@ -192,8 +194,6 @@
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::hemm( order(), side, uplo(), size_row(c),
                 size_column(c), alpha, begin_value(a), stride_major(a),
                 begin_value(b), stride_major(b), beta, begin_value(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -60,8 +60,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -76,8 +76,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -94,8 +94,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -110,8 +110,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -127,8 +127,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -143,8 +143,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -181,6 +181,9 @@
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const MatrixB& b, const real_type beta, MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixB >::type order;
+ typedef typename result_of::data_side< MatrixC >::type uplo;
+ typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
@@ -188,9 +191,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
- typedef typename result_of::data_order< MatrixB >::type order;
- typedef typename result_of::data_side< MatrixC >::type uplo;
- typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         detail::her2k( order(), uplo(), trans(), size_column(c),
                 size_column(a), alpha, begin_value(a), stride_major(a),
                 begin_value(b), stride_major(b), beta, begin_value(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -60,8 +60,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -90,8 +90,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -105,8 +105,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -121,8 +121,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -136,8 +136,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -173,13 +173,13 @@
     template< typename MatrixA, typename MatrixC >
     static return_type invoke( const real_type alpha, const MatrixA& a,
             const real_type beta, MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixC >::type order;
+ typedef typename result_of::data_side< MatrixC >::type uplo;
+ typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
- typedef typename result_of::data_order< MatrixC >::type order;
- typedef typename result_of::data_side< MatrixC >::type uplo;
- typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         detail::herk( order(), uplo(), trans(), size_column(c),
                 size_column(a), alpha, begin_value(a), stride_major(a), beta,
                 begin_value(c), stride_major(c) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -59,8 +59,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -89,8 +89,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -106,8 +106,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -124,8 +124,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -139,8 +139,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -154,8 +154,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -171,8 +171,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -188,8 +188,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -203,8 +203,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -218,8 +218,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -235,8 +235,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo >
inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
@@ -274,6 +274,8 @@
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, const MatrixB& b, const value_type beta,
             MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixA >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
@@ -282,8 +284,6 @@
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- typedef typename result_of::data_order< MatrixA >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
         detail::symm( order(), side, uplo(), size_row(c),
                 size_column(c), alpha, begin_value(a), stride_major(a),
                 begin_value(b), stride_major(b), beta, begin_value(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -60,8 +60,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -75,8 +75,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -90,8 +90,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -107,8 +107,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -125,8 +125,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -140,8 +140,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -155,8 +155,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -172,8 +172,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -189,8 +189,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -204,8 +204,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -219,8 +219,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -236,8 +236,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -274,6 +274,9 @@
     template< typename MatrixA, typename MatrixB, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const MatrixB& b, const value_type beta, MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixB >::type order;
+ typedef typename result_of::data_side< MatrixC >::type uplo;
+ typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
@@ -281,9 +284,6 @@
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
- typedef typename result_of::data_order< MatrixB >::type order;
- typedef typename result_of::data_side< MatrixC >::type uplo;
- typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         detail::syr2k( order(), uplo(), trans(), size_column(c),
                 size_column(a), alpha, begin_value(a), stride_major(a),
                 begin_value(b), stride_major(b), beta, begin_value(c),

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -60,8 +60,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -74,8 +74,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -88,8 +88,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -104,8 +104,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -121,8 +121,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -136,8 +136,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -151,8 +151,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -167,8 +167,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -184,8 +184,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -199,8 +199,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -214,8 +214,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -230,8 +230,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
@@ -267,13 +267,13 @@
     template< typename MatrixA, typename MatrixC >
     static return_type invoke( const value_type alpha, const MatrixA& a,
             const value_type beta, MatrixC& c ) {
+ typedef typename result_of::data_order< MatrixC >::type order;
+ typedef typename result_of::data_side< MatrixC >::type uplo;
+ typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixC >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value ) );
- typedef typename result_of::data_order< MatrixC >::type order;
- typedef typename result_of::data_side< MatrixC >::type uplo;
- typedef typename result_of::trans_tag< MatrixA, order >::type trans;
         detail::syrk( order(), uplo(), trans(), size_column(c),
                 size_column(a), alpha, begin_value(a), stride_major(a), beta,
                 begin_value(c), stride_major(c) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -76,8 +76,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -91,8 +91,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -107,8 +107,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -124,8 +124,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -140,8 +140,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -156,8 +156,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -173,8 +173,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -189,8 +189,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -205,8 +205,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -221,8 +221,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -238,8 +238,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trmm( Order, const char side, UpLo, TransA, Diag,
@@ -276,15 +276,15 @@
     template< typename MatrixA, typename MatrixB >
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, MatrixB& b ) {
+ typedef typename result_of::data_order< MatrixB >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ typedef typename result_of::trans_tag< MatrixA, order >::type transa;
+ typedef typename result_of::diag_tag< MatrixA >::type diag;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value ) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- typedef typename result_of::data_order< MatrixB >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
- typedef typename result_of::trans_tag< MatrixA, order >::type transa;
- typedef typename result_of::diag_tag< MatrixA >::type diag;
         detail::trmm( order(), side, uplo(), transa(), diag(),
                 size_row(b), size_column(b), alpha, begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b) );

Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp 2009-12-30 04:33:04 EST (Wed, 30 Dec 2009)
@@ -61,8 +61,8 @@
#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS
//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * float value-type
+// * CBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -76,8 +76,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * double value-type
+// * CBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -91,8 +91,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<float> value-type
+// * CBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -107,8 +107,8 @@

//
// Overloaded function for dispatching to
-// * CBLAS backend
-// * complex<double> value-type
+// * CBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -124,8 +124,8 @@
#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS
//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * float value-type
+// * CUBLAS backend, and
+// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -140,8 +140,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * double value-type
+// * CUBLAS backend, and
+// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -156,8 +156,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<float> value-type
+// * CUBLAS backend, and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -173,8 +173,8 @@

//
// Overloaded function for dispatching to
-// * CUBLAS backend
-// * complex<double> value-type
+// * CUBLAS backend, and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -191,8 +191,8 @@
#else
//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * float value-type
+// * netlib-compatible BLAS backend (the default), and
+// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -207,8 +207,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * double value-type
+// * netlib-compatible BLAS backend (the default), and
+// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -223,8 +223,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<float> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -240,8 +240,8 @@

//
// Overloaded function for dispatching to
-// * netlib-compatible BLAS backend (the default)
-// * complex<double> value-type
+// * netlib-compatible BLAS backend (the default), and
+// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
inline void trsm( Order, const char side, UpLo, TransA, Diag,
@@ -278,15 +278,15 @@
     template< typename MatrixA, typename MatrixB >
     static return_type invoke( const char side, const value_type alpha,
             const MatrixA& a, MatrixB& b ) {
+ typedef typename result_of::data_order< MatrixB >::type order;
+ typedef typename result_of::data_side< MatrixA >::type uplo;
+ typedef typename result_of::trans_tag< MatrixA, order >::type transa;
+ typedef typename result_of::diag_tag< MatrixA >::type diag;
         BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
                 MatrixA >::type >::type, typename remove_const<
                 typename value< MatrixB >::type >::type >::value) );
         BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value ) );
         BOOST_ASSERT( side == 'L' || side == 'R' );
- typedef typename result_of::data_order< MatrixB >::type order;
- typedef typename result_of::data_side< MatrixA >::type uplo;
- typedef typename result_of::trans_tag< MatrixA, order >::type transa;
- typedef typename result_of::diag_tag< MatrixA >::type diag;
         detail::trsm( order(), side, uplo(), transa(), diag(),
                 size_row(b), size_column(b), alpha, begin_value(a),
                 stride_major(a), begin_value(b), stride_major(b) );

Next message: thomas.klimpel_at_[hidden]: "[Boost-commit] svn:boost r58582 - sandbox/numeric_bindings-v1"
Previous message: rutger_at_[hidden]: "[Boost-commit] svn:boost r58580 - in sandbox/numeric_bindings/libs/numeric/bindings/tools: . templates"

Date view	Thread view	Subject view	Author view

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