|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r58710 - in sandbox/numeric_bindings/boost/numeric/bindings/blas: detail level1 level2 level3
From: rutger_at_[hidden]
Date: 2010-01-05 12:00:34
Author: rutger
Date: 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
New Revision: 58710
URL: http://svn.boost.org/trac/boost/changeset/58710
Log:
Sync of the latest BLAS bindings
Text files modified:
sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas.h | 766 +++++++++++++++++++--------------------
sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas_names.h | 2
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/asum.hpp | 18
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/axpy.hpp | 60 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/copy.hpp | 52 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dot.hpp | 28
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotc.hpp | 32
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/dotu.hpp | 32
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/nrm2.hpp | 18
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rot.hpp | 32
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp | 62 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotmg.hpp | 17
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/scal.hpp | 44 -
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/sdot.hpp | 15
sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/swap.hpp | 54 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gbmv.hpp | 144 +++----
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gemv.hpp | 105 ++---
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/ger.hpp | 41 -
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/gerc.hpp | 55 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/geru.hpp | 55 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hbmv.hpp | 91 ++--
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hemv.hpp | 59 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her.hpp | 39 +
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/her2.hpp | 55 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpmv.hpp | 55 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr.hpp | 31
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/hpr2.hpp | 47 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/sbmv.hpp | 75 +--
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spmv.hpp | 35
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr.hpp | 27
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/spr2.hpp | 33
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/symv.hpp | 41 -
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr.hpp | 33
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/syr2.hpp | 35
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbmv.hpp | 76 +--
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tbsv.hpp | 76 +--
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpmv.hpp | 55 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/tpsv.hpp | 55 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trmv.hpp | 69 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level2/trsv.hpp | 69 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/gemm.hpp | 118 ++---
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/hemm.hpp | 66 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/her2k.hpp | 62 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/herk.hpp | 49 +-
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/symm.hpp | 108 ++---
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syr2k.hpp | 108 ++---
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/syrk.hpp | 92 +--
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trmm.hpp | 92 +--
sandbox/numeric_bindings/boost/numeric/bindings/blas/level3/trsm.hpp | 92 +--
49 files changed, 1556 insertions(+), 1919 deletions(-)
Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas.h
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas.h (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas.h 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -23,67 +23,62 @@
//
// Value-type variants of asum
-float BLAS_SASUM( const std::ptrdiff_t* n, const float* x,
- const std::ptrdiff_t* incx );
-double BLAS_DASUM( const std::ptrdiff_t* n, const double* x,
- const std::ptrdiff_t* incx );
+float BLAS_SASUM( const fortran_int_t* n, const float* x,
+ const fortran_int_t* incx );
+double BLAS_DASUM( const fortran_int_t* n, const double* x,
+ const fortran_int_t* incx );
// Value-type variants of axpy
-void BLAS_SAXPY( const std::ptrdiff_t* n, const float* a, const float* x,
- const std::ptrdiff_t* incx, float* y, const std::ptrdiff_t* incy );
-void BLAS_DAXPY( const std::ptrdiff_t* n, const double* a, const double* x,
- const std::ptrdiff_t* incx, double* y, const std::ptrdiff_t* incy );
-void BLAS_CAXPY( const std::ptrdiff_t* n, const void* a, const void* x,
- const std::ptrdiff_t* incx, void* y, const std::ptrdiff_t* incy );
-void BLAS_ZAXPY( const std::ptrdiff_t* n, const void* a, const void* x,
- const std::ptrdiff_t* incx, void* y, const std::ptrdiff_t* incy );
+void BLAS_SAXPY( const fortran_int_t* n, const float* a, const float* x,
+ const fortran_int_t* incx, float* y, const fortran_int_t* incy );
+void BLAS_DAXPY( const fortran_int_t* n, const double* a, const double* x,
+ const fortran_int_t* incx, double* y, const fortran_int_t* incy );
+void BLAS_CAXPY( const fortran_int_t* n, const void* a, const void* x,
+ const fortran_int_t* incx, void* y, const fortran_int_t* incy );
+void BLAS_ZAXPY( const fortran_int_t* n, const void* a, const void* x,
+ const fortran_int_t* incx, void* y, const fortran_int_t* incy );
// Value-type variants of copy
-void BLAS_SCOPY( const std::ptrdiff_t* n, const float* x,
- const std::ptrdiff_t* incx, float* y, const std::ptrdiff_t* incy );
-void BLAS_DCOPY( const std::ptrdiff_t* n, const double* x,
- const std::ptrdiff_t* incx, double* y, const std::ptrdiff_t* incy );
-void BLAS_CCOPY( const std::ptrdiff_t* n, const void* x,
- const std::ptrdiff_t* incx, void* y, const std::ptrdiff_t* incy );
-void BLAS_ZCOPY( const std::ptrdiff_t* n, const void* x,
- const std::ptrdiff_t* incx, void* y, const std::ptrdiff_t* incy );
+void BLAS_SCOPY( const fortran_int_t* n, const float* x,
+ const fortran_int_t* incx, float* y, const fortran_int_t* incy );
+void BLAS_DCOPY( const fortran_int_t* n, const double* x,
+ const fortran_int_t* incx, double* y, const fortran_int_t* incy );
+void BLAS_CCOPY( const fortran_int_t* n, const void* x,
+ const fortran_int_t* incx, void* y, const fortran_int_t* incy );
+void BLAS_ZCOPY( const fortran_int_t* n, const void* x,
+ const fortran_int_t* incx, void* y, const fortran_int_t* incy );
// Value-type variants of dot
-float BLAS_SDOT( const std::ptrdiff_t* n, const float* x,
- const std::ptrdiff_t* incx, const float* y,
- const std::ptrdiff_t* incy );
-double BLAS_DDOT( const std::ptrdiff_t* n, const double* x,
- const std::ptrdiff_t* incx, const double* y,
- const std::ptrdiff_t* incy );
+float BLAS_SDOT( const fortran_int_t* n, const float* x,
+ const fortran_int_t* incx, const float* y, const fortran_int_t* incy );
+double BLAS_DDOT( const fortran_int_t* n, const double* x,
+ const fortran_int_t* incx, const double* y,
+ const fortran_int_t* incy );
// Value-type variants of dotc
-std::complex<float> BLAS_CDOTC( const std::ptrdiff_t* n, const void* x,
- const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy );
-std::complex<double> BLAS_ZDOTC( const std::ptrdiff_t* n, const void* x,
- const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy );
+std::complex<float> BLAS_CDOTC( const fortran_int_t* n, const void* x,
+ const fortran_int_t* incx, const void* y, const fortran_int_t* incy );
+std::complex<double> BLAS_ZDOTC( const fortran_int_t* n, const void* x,
+ const fortran_int_t* incx, const void* y, const fortran_int_t* incy );
// Value-type variants of dotu
-std::complex<float> BLAS_CDOTU( const std::ptrdiff_t* n, const void* x,
- const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy );
-std::complex<double> BLAS_ZDOTU( const std::ptrdiff_t* n, const void* x,
- const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy );
+std::complex<float> BLAS_CDOTU( const fortran_int_t* n, const void* x,
+ const fortran_int_t* incx, const void* y, const fortran_int_t* incy );
+std::complex<double> BLAS_ZDOTU( const fortran_int_t* n, const void* x,
+ const fortran_int_t* incx, const void* y, const fortran_int_t* incy );
// Value-type variants of nrm2
-float BLAS_SNRM2( const std::ptrdiff_t* n, const float* x,
- const std::ptrdiff_t* incx );
-double BLAS_DNRM2( const std::ptrdiff_t* n, const double* x,
- const std::ptrdiff_t* incx );
+float BLAS_SNRM2( const fortran_int_t* n, const float* x,
+ const fortran_int_t* incx );
+double BLAS_DNRM2( const fortran_int_t* n, const double* x,
+ const fortran_int_t* incx );
// Value-type variants of rot
-void BLAS_SROT( const std::ptrdiff_t* n, const float* x,
- const std::ptrdiff_t* incx, float* y, const std::ptrdiff_t* incy,
+void BLAS_SROT( const fortran_int_t* n, const float* x,
+ const fortran_int_t* incx, float* y, const fortran_int_t* incy,
const float* c, const float* s );
-void BLAS_DROT( const std::ptrdiff_t* n, const double* x,
- const std::ptrdiff_t* incx, double* y, const std::ptrdiff_t* incy,
+void BLAS_DROT( const fortran_int_t* n, const double* x,
+ const fortran_int_t* incx, double* y, const fortran_int_t* incy,
const double* c, const double* s );
// Value-type variants of rotg
@@ -91,12 +86,10 @@
void BLAS_DROTG( double* a, double* b, double* c, double* s );
// Value-type variants of rotm
-void BLAS_SROTM( const std::ptrdiff_t* n, float* x,
- const std::ptrdiff_t* incx, float* y, const std::ptrdiff_t* incy,
- float* param );
-void BLAS_DROTM( const std::ptrdiff_t* n, double* x,
- const std::ptrdiff_t* incx, double* y, const std::ptrdiff_t* incy,
- double* param );
+void BLAS_SROTM( const fortran_int_t* n, float* x, const fortran_int_t* incx,
+ float* y, const fortran_int_t* incy, float* param );
+void BLAS_DROTM( const fortran_int_t* n, double* x, const fortran_int_t* incx,
+ double* y, const fortran_int_t* incy, double* param );
// Value-type variants of rotmg
void BLAS_SROTMG( float* d1, float* d2, float* x1, const float* y1,
@@ -105,312 +98,305 @@
double* dparam );
// Value-type variants of scal
-void BLAS_SSCAL( const std::ptrdiff_t* n, const float* a, float* x,
- const std::ptrdiff_t* incx );
-void BLAS_DSCAL( const std::ptrdiff_t* n, const double* a, double* x,
- const std::ptrdiff_t* incx );
-void BLAS_CSCAL( const std::ptrdiff_t* n, const void* a, void* x,
- const std::ptrdiff_t* incx );
-void BLAS_ZSCAL( const std::ptrdiff_t* n, const void* a, void* x,
- const std::ptrdiff_t* incx );
+void BLAS_SSCAL( const fortran_int_t* n, const float* a, float* x,
+ const fortran_int_t* incx );
+void BLAS_DSCAL( const fortran_int_t* n, const double* a, double* x,
+ const fortran_int_t* incx );
+void BLAS_CSCAL( const fortran_int_t* n, const void* a, void* x,
+ const fortran_int_t* incx );
+void BLAS_ZSCAL( const fortran_int_t* n, const void* a, void* x,
+ const fortran_int_t* incx );
// Value-type variants of sdot
-double BLAS_DSDOT( const std::ptrdiff_t* n, const float* sx,
- const std::ptrdiff_t* incx, const float* sy,
- const std::ptrdiff_t* incy );
+double BLAS_DSDOT( const fortran_int_t* n, const float* sx,
+ const fortran_int_t* incx, const float* sy,
+ const fortran_int_t* incy );
// Value-type variants of swap
-void BLAS_SSWAP( const std::ptrdiff_t* n, float* x,
- const std::ptrdiff_t* incx, float* y, const std::ptrdiff_t* incy );
-void BLAS_DSWAP( const std::ptrdiff_t* n, double* x,
- const std::ptrdiff_t* incx, double* y, const std::ptrdiff_t* incy );
-void BLAS_CSWAP( const std::ptrdiff_t* n, void* x, const std::ptrdiff_t* incx,
- void* y, const std::ptrdiff_t* incy );
-void BLAS_ZSWAP( const std::ptrdiff_t* n, void* x, const std::ptrdiff_t* incx,
- void* y, const std::ptrdiff_t* incy );
+void BLAS_SSWAP( const fortran_int_t* n, float* x, const fortran_int_t* incx,
+ float* y, const fortran_int_t* incy );
+void BLAS_DSWAP( const fortran_int_t* n, double* x, const fortran_int_t* incx,
+ double* y, const fortran_int_t* incy );
+void BLAS_CSWAP( const fortran_int_t* n, void* x, const fortran_int_t* incx,
+ void* y, const fortran_int_t* incy );
+void BLAS_ZSWAP( const fortran_int_t* n, void* x, const fortran_int_t* incx,
+ void* y, const fortran_int_t* incy );
//
// BLAS level2 routines
//
// Value-type variants of gbmv
-void BLAS_SGBMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const std::ptrdiff_t* kl,
- const std::ptrdiff_t* ku, const float* alpha, const float* a,
- const std::ptrdiff_t* lda, const float* x, const std::ptrdiff_t* incx,
- const float* beta, float* y, const std::ptrdiff_t* incy );
-void BLAS_DGBMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const std::ptrdiff_t* kl,
- const std::ptrdiff_t* ku, const double* alpha, const double* a,
- const std::ptrdiff_t* lda, const double* x,
- const std::ptrdiff_t* incx, const double* beta, double* y,
- const std::ptrdiff_t* incy );
-void BLAS_CGBMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const std::ptrdiff_t* kl,
- const std::ptrdiff_t* ku, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
-void BLAS_ZGBMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const std::ptrdiff_t* kl,
- const std::ptrdiff_t* ku, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
+void BLAS_SGBMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* kl,
+ const fortran_int_t* ku, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* x, const fortran_int_t* incx,
+ const float* beta, float* y, const fortran_int_t* incy );
+void BLAS_DGBMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* kl,
+ const fortran_int_t* ku, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* x, const fortran_int_t* incx,
+ const double* beta, double* y, const fortran_int_t* incy );
+void BLAS_CGBMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* kl,
+ const fortran_int_t* ku, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
+void BLAS_ZGBMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* kl,
+ const fortran_int_t* ku, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
// Value-type variants of gemv
-void BLAS_SGEMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const float* alpha, const float* a,
- const std::ptrdiff_t* lda, const float* x, const std::ptrdiff_t* incx,
- const float* beta, float* y, const std::ptrdiff_t* incy );
-void BLAS_DGEMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const double* alpha, const double* a,
- const std::ptrdiff_t* lda, const double* x,
- const std::ptrdiff_t* incx, const double* beta, double* y,
- const std::ptrdiff_t* incy );
-void BLAS_CGEMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
-void BLAS_ZGEMV( const char* trans, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
+void BLAS_SGEMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* x, const fortran_int_t* incx,
+ const float* beta, float* y, const fortran_int_t* incy );
+void BLAS_DGEMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* x, const fortran_int_t* incx,
+ const double* beta, double* y, const fortran_int_t* incy );
+void BLAS_CGEMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
+void BLAS_ZGEMV( const char* trans, const fortran_int_t* m,
+ const fortran_int_t* n, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
// Value-type variants of ger
-void BLAS_SGER( const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const float* alpha, const float* x, const std::ptrdiff_t* incx,
- const float* y, const std::ptrdiff_t* incy, float* a,
- const std::ptrdiff_t* lda );
-void BLAS_DGER( const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const double* alpha, const double* x, const std::ptrdiff_t* incx,
- const double* y, const std::ptrdiff_t* incy, double* a,
- const std::ptrdiff_t* lda );
+void BLAS_SGER( const fortran_int_t* m, const fortran_int_t* n,
+ const float* alpha, const float* x, const fortran_int_t* incx,
+ const float* y, const fortran_int_t* incy, float* a,
+ const fortran_int_t* lda );
+void BLAS_DGER( const fortran_int_t* m, const fortran_int_t* n,
+ const double* alpha, const double* x, const fortran_int_t* incx,
+ const double* y, const fortran_int_t* incy, double* a,
+ const fortran_int_t* lda );
// Value-type variants of gerc
-void BLAS_CGERC( const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* x, const std::ptrdiff_t* incx,
- const void* y, const std::ptrdiff_t* incy, void* a,
- const std::ptrdiff_t* lda );
-void BLAS_ZGERC( const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* x, const std::ptrdiff_t* incx,
- const void* y, const std::ptrdiff_t* incy, void* a,
- const std::ptrdiff_t* lda );
+void BLAS_CGERC( const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* x, const fortran_int_t* incx,
+ const void* y, const fortran_int_t* incy, void* a,
+ const fortran_int_t* lda );
+void BLAS_ZGERC( const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* x, const fortran_int_t* incx,
+ const void* y, const fortran_int_t* incy, void* a,
+ const fortran_int_t* lda );
// Value-type variants of geru
-void BLAS_CGERU( const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* x, const std::ptrdiff_t* incx,
- const void* y, const std::ptrdiff_t* incy, void* a,
- const std::ptrdiff_t* lda );
-void BLAS_ZGERU( const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* x, const std::ptrdiff_t* incx,
- const void* y, const std::ptrdiff_t* incy, void* a,
- const std::ptrdiff_t* lda );
+void BLAS_CGERU( const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* x, const fortran_int_t* incx,
+ const void* y, const fortran_int_t* incy, void* a,
+ const fortran_int_t* lda );
+void BLAS_ZGERU( const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* x, const fortran_int_t* incx,
+ const void* y, const fortran_int_t* incy, void* a,
+ const fortran_int_t* lda );
// Value-type variants of hbmv
-void BLAS_CHBMV( const char* uplo, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
-void BLAS_ZHBMV( const char* uplo, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
+void BLAS_CHBMV( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
+void BLAS_ZHBMV( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
// Value-type variants of hemv
-void BLAS_CHEMV( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* a, const std::ptrdiff_t* lda, const void* x,
- const std::ptrdiff_t* incx, const void* beta, void* y,
- const std::ptrdiff_t* incy );
-void BLAS_ZHEMV( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* a, const std::ptrdiff_t* lda, const void* x,
- const std::ptrdiff_t* incx, const void* beta, void* y,
- const std::ptrdiff_t* incy );
+void BLAS_CHEMV( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* a, const fortran_int_t* lda, const void* x,
+ const fortran_int_t* incx, const void* beta, void* y,
+ const fortran_int_t* incy );
+void BLAS_ZHEMV( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* a, const fortran_int_t* lda, const void* x,
+ const fortran_int_t* incx, const void* beta, void* y,
+ const fortran_int_t* incy );
// Value-type variants of her
-void BLAS_CHER( const char* uplo, const std::ptrdiff_t* n, const float* alpha,
- const void* x, const std::ptrdiff_t* incx, void* a,
- const std::ptrdiff_t* lda );
-void BLAS_ZHER( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const void* x, const std::ptrdiff_t* incx,
- void* a, const std::ptrdiff_t* lda );
+void BLAS_CHER( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const void* x, const fortran_int_t* incx, void* a,
+ const fortran_int_t* lda );
+void BLAS_ZHER( const char* uplo, const fortran_int_t* n, const double* alpha,
+ const void* x, const fortran_int_t* incx, void* a,
+ const fortran_int_t* lda );
// Value-type variants of her2
-void BLAS_CHER2( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* x, const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy, void* a, const std::ptrdiff_t* lda );
-void BLAS_ZHER2( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* x, const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy, void* a, const std::ptrdiff_t* lda );
+void BLAS_CHER2( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* x, const fortran_int_t* incx, const void* y,
+ const fortran_int_t* incy, void* a, const fortran_int_t* lda );
+void BLAS_ZHER2( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* x, const fortran_int_t* incx, const void* y,
+ const fortran_int_t* incy, void* a, const fortran_int_t* lda );
// Value-type variants of hpmv
-void BLAS_CHPMV( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* ap, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
-void BLAS_ZHPMV( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* ap, const void* x, const std::ptrdiff_t* incx,
- const void* beta, void* y, const std::ptrdiff_t* incy );
+void BLAS_CHPMV( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* ap, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
+void BLAS_ZHPMV( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* ap, const void* x, const fortran_int_t* incx,
+ const void* beta, void* y, const fortran_int_t* incy );
// Value-type variants of hpr
-void BLAS_CHPR( const char* uplo, const std::ptrdiff_t* n, const float* alpha,
- const void* x, const std::ptrdiff_t* incx, void* ap );
-void BLAS_ZHPR( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const void* x, const std::ptrdiff_t* incx,
- void* ap );
+void BLAS_CHPR( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const void* x, const fortran_int_t* incx, void* ap );
+void BLAS_ZHPR( const char* uplo, const fortran_int_t* n, const double* alpha,
+ const void* x, const fortran_int_t* incx, void* ap );
// Value-type variants of hpr2
-void BLAS_CHPR2( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* x, const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy, void* ap );
-void BLAS_ZHPR2( const char* uplo, const std::ptrdiff_t* n, const void* alpha,
- const void* x, const std::ptrdiff_t* incx, const void* y,
- const std::ptrdiff_t* incy, void* ap );
+void BLAS_CHPR2( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* x, const fortran_int_t* incx, const void* y,
+ const fortran_int_t* incy, void* ap );
+void BLAS_ZHPR2( const char* uplo, const fortran_int_t* n, const void* alpha,
+ const void* x, const fortran_int_t* incx, const void* y,
+ const fortran_int_t* incy, void* ap );
// Value-type variants of sbmv
-void BLAS_SSBMV( const char* uplo, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const float* alpha, const float* a,
- const std::ptrdiff_t* lda, const float* x, const std::ptrdiff_t* incx,
- const float* beta, float* y, const std::ptrdiff_t* incy );
-void BLAS_DSBMV( const char* uplo, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const double* alpha, const double* a,
- const std::ptrdiff_t* lda, const double* x,
- const std::ptrdiff_t* incx, const double* beta, double* y,
- const std::ptrdiff_t* incy );
+void BLAS_SSBMV( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* k, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* x, const fortran_int_t* incx,
+ const float* beta, float* y, const fortran_int_t* incy );
+void BLAS_DSBMV( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* k, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* x, const fortran_int_t* incx,
+ const double* beta, double* y, const fortran_int_t* incy );
// Value-type variants of spmv
-void BLAS_SSPMV( const char* uplo, const std::ptrdiff_t* n,
- const float* alpha, const float* ap, const float* x,
- const std::ptrdiff_t* incx, const float* beta, float* y,
- const std::ptrdiff_t* incy );
-void BLAS_DSPMV( const char* uplo, const std::ptrdiff_t* n,
+void BLAS_SSPMV( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const float* ap, const float* x, const fortran_int_t* incx,
+ const float* beta, float* y, const fortran_int_t* incy );
+void BLAS_DSPMV( const char* uplo, const fortran_int_t* n,
const double* alpha, const double* ap, const double* x,
- const std::ptrdiff_t* incx, const double* beta, double* y,
- const std::ptrdiff_t* incy );
+ const fortran_int_t* incx, const double* beta, double* y,
+ const fortran_int_t* incy );
// Value-type variants of spr
-void BLAS_SSPR( const char* uplo, const std::ptrdiff_t* n, const float* alpha,
- const float* x, const std::ptrdiff_t* incx, float* ap );
-void BLAS_DSPR( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const double* x, const std::ptrdiff_t* incx,
- double* ap );
+void BLAS_SSPR( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const float* x, const fortran_int_t* incx, float* ap );
+void BLAS_DSPR( const char* uplo, const fortran_int_t* n, const double* alpha,
+ const double* x, const fortran_int_t* incx, double* ap );
// Value-type variants of spr2
-void BLAS_SSPR2( const char* uplo, const std::ptrdiff_t* n,
- const float* alpha, const float* x, const std::ptrdiff_t* incx,
- const float* y, const std::ptrdiff_t* incy, float* ap );
-void BLAS_DSPR2( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const double* x, const std::ptrdiff_t* incx,
- const double* y, const std::ptrdiff_t* incy, double* ap );
+void BLAS_SSPR2( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const float* x, const fortran_int_t* incx, const float* y,
+ const fortran_int_t* incy, float* ap );
+void BLAS_DSPR2( const char* uplo, const fortran_int_t* n,
+ const double* alpha, const double* x, const fortran_int_t* incx,
+ const double* y, const fortran_int_t* incy, double* ap );
// Value-type variants of symv
-void BLAS_SSYMV( const char* uplo, const std::ptrdiff_t* n,
- const float* alpha, const float* a, const std::ptrdiff_t* lda,
- const float* x, const std::ptrdiff_t* incx, const float* beta,
- float* y, const std::ptrdiff_t* incy );
-void BLAS_DSYMV( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const double* a, const std::ptrdiff_t* lda,
- const double* x, const std::ptrdiff_t* incx, const double* beta,
- double* y, const std::ptrdiff_t* incy );
+void BLAS_SSYMV( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const float* a, const fortran_int_t* lda, const float* x,
+ const fortran_int_t* incx, const float* beta, float* y,
+ const fortran_int_t* incy );
+void BLAS_DSYMV( const char* uplo, const fortran_int_t* n,
+ const double* alpha, const double* a, const fortran_int_t* lda,
+ const double* x, const fortran_int_t* incx, const double* beta,
+ double* y, const fortran_int_t* incy );
// Value-type variants of syr
-void BLAS_SSYR( const char* uplo, const std::ptrdiff_t* n, const float* alpha,
- const float* x, const std::ptrdiff_t* incx, float* a,
- const std::ptrdiff_t* lda );
-void BLAS_DSYR( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const double* x, const std::ptrdiff_t* incx,
- double* a, const std::ptrdiff_t* lda );
+void BLAS_SSYR( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const float* x, const fortran_int_t* incx, float* a,
+ const fortran_int_t* lda );
+void BLAS_DSYR( const char* uplo, const fortran_int_t* n, const double* alpha,
+ const double* x, const fortran_int_t* incx, double* a,
+ const fortran_int_t* lda );
// Value-type variants of syr2
-void BLAS_SSYR2( const char* uplo, const std::ptrdiff_t* n,
- const float* alpha, const float* x, const std::ptrdiff_t* incx,
- const float* y, const std::ptrdiff_t* incy, float* a,
- const std::ptrdiff_t* lda );
-void BLAS_DSYR2( const char* uplo, const std::ptrdiff_t* n,
- const double* alpha, const double* x, const std::ptrdiff_t* incx,
- const double* y, const std::ptrdiff_t* incy, double* a,
- const std::ptrdiff_t* lda );
+void BLAS_SSYR2( const char* uplo, const fortran_int_t* n, const float* alpha,
+ const float* x, const fortran_int_t* incx, const float* y,
+ const fortran_int_t* incy, float* a, const fortran_int_t* lda );
+void BLAS_DSYR2( const char* uplo, const fortran_int_t* n,
+ const double* alpha, const double* x, const fortran_int_t* incx,
+ const double* y, const fortran_int_t* incy, double* a,
+ const fortran_int_t* lda );
// Value-type variants of tbmv
void BLAS_STBMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const float* a,
- const std::ptrdiff_t* lda, float* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const float* a,
+ const fortran_int_t* lda, float* x, const fortran_int_t* incx );
void BLAS_DTBMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const double* a,
- const std::ptrdiff_t* lda, double* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const double* a,
+ const fortran_int_t* lda, double* x, const fortran_int_t* incx );
void BLAS_CTBMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* a,
- const std::ptrdiff_t* lda, void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const void* a,
+ const fortran_int_t* lda, void* x, const fortran_int_t* incx );
void BLAS_ZTBMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* a,
- const std::ptrdiff_t* lda, void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const void* a,
+ const fortran_int_t* lda, void* x, const fortran_int_t* incx );
// Value-type variants of tbsv
void BLAS_STBSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const float* a,
- const std::ptrdiff_t* lda, float* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const float* a,
+ const fortran_int_t* lda, float* x, const fortran_int_t* incx );
void BLAS_DTBSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const double* a,
- const std::ptrdiff_t* lda, double* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const double* a,
+ const fortran_int_t* lda, double* x, const fortran_int_t* incx );
void BLAS_CTBSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* a,
- const std::ptrdiff_t* lda, void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const void* a,
+ const fortran_int_t* lda, void* x, const fortran_int_t* incx );
void BLAS_ZTBSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* a,
- const std::ptrdiff_t* lda, void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const fortran_int_t* k, const void* a,
+ const fortran_int_t* lda, void* x, const fortran_int_t* incx );
// Value-type variants of tpmv
void BLAS_STPMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const float* ap, float* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const float* ap, float* x,
+ const fortran_int_t* incx );
void BLAS_DTPMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const double* ap, double* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const double* ap, double* x,
+ const fortran_int_t* incx );
void BLAS_CTPMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* ap, void* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* ap, void* x,
+ const fortran_int_t* incx );
void BLAS_ZTPMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* ap, void* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* ap, void* x,
+ const fortran_int_t* incx );
// Value-type variants of tpsv
void BLAS_STPSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const float* ap, float* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const float* ap, float* x,
+ const fortran_int_t* incx );
void BLAS_DTPSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const double* ap, double* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const double* ap, double* x,
+ const fortran_int_t* incx );
void BLAS_CTPSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* ap, void* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* ap, void* x,
+ const fortran_int_t* incx );
void BLAS_ZTPSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* ap, void* x,
- const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* ap, void* x,
+ const fortran_int_t* incx );
// Value-type variants of trmv
void BLAS_STRMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const float* a, const std::ptrdiff_t* lda,
- float* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const float* a, const fortran_int_t* lda,
+ float* x, const fortran_int_t* incx );
void BLAS_DTRMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const double* a, const std::ptrdiff_t* lda,
- double* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const double* a, const fortran_int_t* lda,
+ double* x, const fortran_int_t* incx );
void BLAS_CTRMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* a, const std::ptrdiff_t* lda,
- void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* a, const fortran_int_t* lda,
+ void* x, const fortran_int_t* incx );
void BLAS_ZTRMV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* a, const std::ptrdiff_t* lda,
- void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* a, const fortran_int_t* lda,
+ void* x, const fortran_int_t* incx );
// Value-type variants of trsv
void BLAS_STRSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const float* a, const std::ptrdiff_t* lda,
- float* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const float* a, const fortran_int_t* lda,
+ float* x, const fortran_int_t* incx );
void BLAS_DTRSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const double* a, const std::ptrdiff_t* lda,
- double* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const double* a, const fortran_int_t* lda,
+ double* x, const fortran_int_t* incx );
void BLAS_CTRSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* a, const std::ptrdiff_t* lda,
- void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* a, const fortran_int_t* lda,
+ void* x, const fortran_int_t* incx );
void BLAS_ZTRSV( const char* uplo, const char* trans, const char* diag,
- const std::ptrdiff_t* n, const void* a, const std::ptrdiff_t* lda,
- void* x, const std::ptrdiff_t* incx );
+ const fortran_int_t* n, const void* a, const fortran_int_t* lda,
+ void* x, const fortran_int_t* incx );
//
// BLAS level3 routines
@@ -418,151 +404,145 @@
// Value-type variants of gemm
void BLAS_SGEMM( const char* transa, const char* transb,
- const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const float* alpha, const float* a,
- const std::ptrdiff_t* lda, const float* b, const std::ptrdiff_t* ldb,
- const float* beta, float* c, const std::ptrdiff_t* ldc );
+ const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* k, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* b, const fortran_int_t* ldb,
+ const float* beta, float* c, const fortran_int_t* ldc );
void BLAS_DGEMM( const char* transa, const char* transb,
- const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const double* alpha, const double* a,
- const std::ptrdiff_t* lda, const double* b, const std::ptrdiff_t* ldb,
- const double* beta, double* c, const std::ptrdiff_t* ldc );
+ const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* k, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* b, const fortran_int_t* ldb,
+ const double* beta, double* c, const fortran_int_t* ldc );
void BLAS_CGEMM( const char* transa, const char* transb,
- const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* b, const std::ptrdiff_t* ldb,
- const void* beta, void* c, const std::ptrdiff_t* ldc );
+ const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
void BLAS_ZGEMM( const char* transa, const char* transb,
- const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* b, const std::ptrdiff_t* ldb,
- const void* beta, void* c, const std::ptrdiff_t* ldc );
+ const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
// Value-type variants of hemm
-void BLAS_CHEMM( const char* side, const char* uplo, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* b, const std::ptrdiff_t* ldb,
- const void* beta, void* c, const std::ptrdiff_t* ldc );
-void BLAS_ZHEMM( const char* side, const char* uplo, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* b, const std::ptrdiff_t* ldb,
- const void* beta, void* c, const std::ptrdiff_t* ldc );
+void BLAS_CHEMM( const char* side, const char* uplo, const fortran_int_t* m,
+ const fortran_int_t* n, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
+void BLAS_ZHEMM( const char* side, const char* uplo, const fortran_int_t* m,
+ const fortran_int_t* n, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
// Value-type variants of her2k
-void BLAS_CHER2K( const char* uplo, const char* trans,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* alpha,
- const void* a, const std::ptrdiff_t* lda, const void* b,
- const std::ptrdiff_t* ldb, const float* beta, void* c,
- const std::ptrdiff_t* ldc );
-void BLAS_ZHER2K( const char* uplo, const char* trans,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* alpha,
- const void* a, const std::ptrdiff_t* lda, const void* b,
- const std::ptrdiff_t* ldb, const double* beta, void* c,
- const std::ptrdiff_t* ldc );
+void BLAS_CHER2K( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const float* beta, void* c, const fortran_int_t* ldc );
+void BLAS_ZHER2K( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const double* beta, void* c, const fortran_int_t* ldc );
// Value-type variants of herk
-void BLAS_CHERK( const char* uplo, const char* trans, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const float* alpha, const void* a,
- const std::ptrdiff_t* lda, const float* beta, void* c,
- const std::ptrdiff_t* ldc );
-void BLAS_ZHERK( const char* uplo, const char* trans, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const double* alpha, const void* a,
- const std::ptrdiff_t* lda, const double* beta, void* c,
- const std::ptrdiff_t* ldc );
+void BLAS_CHERK( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const float* alpha, const void* a,
+ const fortran_int_t* lda, const float* beta, void* c,
+ const fortran_int_t* ldc );
+void BLAS_ZHERK( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const double* alpha, const void* a,
+ const fortran_int_t* lda, const double* beta, void* c,
+ const fortran_int_t* ldc );
// Value-type variants of symm
-void BLAS_SSYMM( const char* side, const char* uplo, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const float* alpha, const float* a,
- const std::ptrdiff_t* lda, const float* b, const std::ptrdiff_t* ldb,
- const float* beta, float* c, const std::ptrdiff_t* ldc );
-void BLAS_DSYMM( const char* side, const char* uplo, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const double* alpha, const double* a,
- const std::ptrdiff_t* lda, const double* b, const std::ptrdiff_t* ldb,
- const double* beta, double* c, const std::ptrdiff_t* ldc );
-void BLAS_CSYMM( const char* side, const char* uplo, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* b, const std::ptrdiff_t* ldb,
- const void* beta, void* c, const std::ptrdiff_t* ldc );
-void BLAS_ZSYMM( const char* side, const char* uplo, const std::ptrdiff_t* m,
- const std::ptrdiff_t* n, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* b, const std::ptrdiff_t* ldb,
- const void* beta, void* c, const std::ptrdiff_t* ldc );
+void BLAS_SSYMM( const char* side, const char* uplo, const fortran_int_t* m,
+ const fortran_int_t* n, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* b, const fortran_int_t* ldb,
+ const float* beta, float* c, const fortran_int_t* ldc );
+void BLAS_DSYMM( const char* side, const char* uplo, const fortran_int_t* m,
+ const fortran_int_t* n, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* b, const fortran_int_t* ldb,
+ const double* beta, double* c, const fortran_int_t* ldc );
+void BLAS_CSYMM( const char* side, const char* uplo, const fortran_int_t* m,
+ const fortran_int_t* n, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
+void BLAS_ZSYMM( const char* side, const char* uplo, const fortran_int_t* m,
+ const fortran_int_t* n, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
// Value-type variants of syr2k
-void BLAS_SSYR2K( const char* uplo, const char* trans,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const float* alpha,
- const float* a, const std::ptrdiff_t* lda, const float* b,
- const std::ptrdiff_t* ldb, const float* beta, float* c,
- const std::ptrdiff_t* ldc );
-void BLAS_DSYR2K( const char* uplo, const char* trans,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const double* alpha,
- const double* a, const std::ptrdiff_t* lda, const double* b,
- const std::ptrdiff_t* ldb, const double* beta, double* c,
- const std::ptrdiff_t* ldc );
-void BLAS_CSYR2K( const char* uplo, const char* trans,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* alpha,
- const void* a, const std::ptrdiff_t* lda, const void* b,
- const std::ptrdiff_t* ldb, const void* beta, void* c,
- const std::ptrdiff_t* ldc );
-void BLAS_ZSYR2K( const char* uplo, const char* trans,
- const std::ptrdiff_t* n, const std::ptrdiff_t* k, const void* alpha,
- const void* a, const std::ptrdiff_t* lda, const void* b,
- const std::ptrdiff_t* ldb, const void* beta, void* c,
- const std::ptrdiff_t* ldc );
+void BLAS_SSYR2K( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* b, const fortran_int_t* ldb,
+ const float* beta, float* c, const fortran_int_t* ldc );
+void BLAS_DSYR2K( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* b, const fortran_int_t* ldb,
+ const double* beta, double* c, const fortran_int_t* ldc );
+void BLAS_CSYR2K( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
+void BLAS_ZSYR2K( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* b, const fortran_int_t* ldb,
+ const void* beta, void* c, const fortran_int_t* ldc );
// Value-type variants of syrk
-void BLAS_SSYRK( const char* uplo, const char* trans, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const float* alpha, const float* a,
- const std::ptrdiff_t* lda, const float* beta, float* c,
- const std::ptrdiff_t* ldc );
-void BLAS_DSYRK( const char* uplo, const char* trans, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const double* alpha, const double* a,
- const std::ptrdiff_t* lda, const double* beta, double* c,
- const std::ptrdiff_t* ldc );
-void BLAS_CSYRK( const char* uplo, const char* trans, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* beta, void* c,
- const std::ptrdiff_t* ldc );
-void BLAS_ZSYRK( const char* uplo, const char* trans, const std::ptrdiff_t* n,
- const std::ptrdiff_t* k, const void* alpha, const void* a,
- const std::ptrdiff_t* lda, const void* beta, void* c,
- const std::ptrdiff_t* ldc );
+void BLAS_SSYRK( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const float* alpha, const float* a,
+ const fortran_int_t* lda, const float* beta, float* c,
+ const fortran_int_t* ldc );
+void BLAS_DSYRK( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const double* alpha, const double* a,
+ const fortran_int_t* lda, const double* beta, double* c,
+ const fortran_int_t* ldc );
+void BLAS_CSYRK( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* beta, void* c,
+ const fortran_int_t* ldc );
+void BLAS_ZSYRK( const char* uplo, const char* trans, const fortran_int_t* n,
+ const fortran_int_t* k, const void* alpha, const void* a,
+ const fortran_int_t* lda, const void* beta, void* c,
+ const fortran_int_t* ldc );
// Value-type variants of trmm
void BLAS_STRMM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const float* alpha, const float* a, const std::ptrdiff_t* lda,
- float* b, const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const float* alpha, const float* a, const fortran_int_t* lda,
+ float* b, const fortran_int_t* ldb );
void BLAS_DTRMM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const double* alpha, const double* a, const std::ptrdiff_t* lda,
- double* b, const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const double* alpha, const double* a, const fortran_int_t* lda,
+ double* b, const fortran_int_t* ldb );
void BLAS_CTRMM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* a, const std::ptrdiff_t* lda, void* b,
- const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* a, const fortran_int_t* lda, void* b,
+ const fortran_int_t* ldb );
void BLAS_ZTRMM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* a, const std::ptrdiff_t* lda, void* b,
- const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* a, const fortran_int_t* lda, void* b,
+ const fortran_int_t* ldb );
// Value-type variants of trsm
void BLAS_STRSM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const float* alpha, const float* a, const std::ptrdiff_t* lda,
- float* b, const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const float* alpha, const float* a, const fortran_int_t* lda,
+ float* b, const fortran_int_t* ldb );
void BLAS_DTRSM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const double* alpha, const double* a, const std::ptrdiff_t* lda,
- double* b, const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const double* alpha, const double* a, const fortran_int_t* lda,
+ double* b, const fortran_int_t* ldb );
void BLAS_CTRSM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* a, const std::ptrdiff_t* lda, void* b,
- const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* a, const fortran_int_t* lda, void* b,
+ const fortran_int_t* ldb );
void BLAS_ZTRSM( const char* side, const char* uplo, const char* transa,
- const char* diag, const std::ptrdiff_t* m, const std::ptrdiff_t* n,
- const void* alpha, const void* a, const std::ptrdiff_t* lda, void* b,
- const std::ptrdiff_t* ldb );
+ const char* diag, const fortran_int_t* m, const fortran_int_t* n,
+ const void* alpha, const void* a, const fortran_int_t* lda, void* b,
+ const fortran_int_t* ldb );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas_names.h
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas_names.h (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/detail/blas_names.h 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -14,7 +14,7 @@
#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_NAMES_H
#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_NAMES_H
-#include <boost/numeric/bindings/detail/fortran.h>
+#include <boost/numeric/bindings/detail/config/fortran.hpp>
//
// BLAS level1 routines
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline float asum( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx ) {
+inline float asum( int n, const float* x, int incx ) {
return cblas_sasum( n, x, incx );
}
@@ -70,8 +69,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline double asum( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx ) {
+inline double asum( int n, const double* x, int incx ) {
return cblas_dasum( n, x, incx );
}
@@ -81,8 +79,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline float asum( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx ) {
+inline float asum( int n, const float* x, int incx ) {
return cublasSasum( n, x, incx );
}
@@ -91,8 +88,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline double asum( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx ) {
+inline double asum( int n, const double* x, int incx ) {
return cublasDasum( n, x, incx );
}
@@ -102,8 +98,7 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline float asum( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx ) {
+inline float asum( fortran_int_t n, const float* x, fortran_int_t incx ) {
return BLAS_SASUM( &n, x, &incx );
}
@@ -112,8 +107,7 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline double asum( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx ) {
+inline double asum( fortran_int_t n, const double* x, fortran_int_t incx ) {
return BLAS_DASUM( &n, x, &incx );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,8 @@
// * CBLAS backend, and
// * float value-type.
//
-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 ) {
+inline void axpy( int n, float a, const float* x, int incx, float* y,
+ int incy ) {
cblas_saxpy( n, a, x, incx, y, incy );
}
@@ -70,8 +70,8 @@
// * CBLAS backend, and
// * double value-type.
//
-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 ) {
+inline void axpy( int n, double a, const double* x, int incx, double* y,
+ int incy ) {
cblas_daxpy( n, a, x, incx, y, incy );
}
@@ -80,9 +80,8 @@
// * CBLAS backend, and
// * complex<float> value-type.
//
-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 ) {
+inline void axpy( int n, std::complex<float> a, const std::complex<float>* x,
+ int incx, std::complex<float>* y, int incy ) {
cblas_caxpy( n, &a, x, incx, y, incy );
}
@@ -91,9 +90,9 @@
// * CBLAS backend, and
// * complex<double> value-type.
//
-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 ) {
+inline void axpy( int n, std::complex<double> a,
+ const std::complex<double>* x, int incx, std::complex<double>* y,
+ int incy ) {
cblas_zaxpy( n, &a, x, incx, y, incy );
}
@@ -103,8 +102,8 @@
// * CUBLAS backend, and
// * float value-type.
//
-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 ) {
+inline void axpy( int n, float a, const float* x, int incx, float* y,
+ int incy ) {
cublasSaxpy( n, a, x, incx, y, incy );
}
@@ -113,8 +112,8 @@
// * CUBLAS backend, and
// * double value-type.
//
-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 ) {
+inline void axpy( int n, double a, const double* x, int incx, double* y,
+ int incy ) {
cublasDaxpy( n, a, x, incx, y, incy );
}
@@ -123,9 +122,8 @@
// * CUBLAS backend, and
// * complex<float> value-type.
//
-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 ) {
+inline void axpy( int n, std::complex<float> a, const std::complex<float>* x,
+ int incx, std::complex<float>* y, int incy ) {
cublasCaxpy( n, a, x, incx, y, incy );
}
@@ -134,9 +132,9 @@
// * CUBLAS backend, and
// * complex<double> value-type.
//
-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 ) {
+inline void axpy( int n, std::complex<double> a,
+ const std::complex<double>* x, int incx, std::complex<double>* y,
+ int incy ) {
// NOT FOUND();
}
@@ -146,8 +144,8 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-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 ) {
+inline void axpy( fortran_int_t n, float a, const float* x,
+ fortran_int_t incx, float* y, fortran_int_t incy ) {
BLAS_SAXPY( &n, &a, x, &incx, y, &incy );
}
@@ -156,8 +154,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-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 ) {
+inline void axpy( fortran_int_t n, double a, const double* x,
+ fortran_int_t incx, double* y, fortran_int_t incy ) {
BLAS_DAXPY( &n, &a, x, &incx, y, &incy );
}
@@ -166,9 +164,9 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<float> value-type.
//
-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 ) {
+inline void axpy( fortran_int_t n, std::complex<float> a,
+ const std::complex<float>* x, fortran_int_t incx,
+ std::complex<float>* y, fortran_int_t incy ) {
BLAS_CAXPY( &n, &a, x, &incx, y, &incy );
}
@@ -177,9 +175,9 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<double> value-type.
//
-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 ) {
+inline void axpy( fortran_int_t n, std::complex<double> a,
+ const std::complex<double>* x, fortran_int_t incx,
+ std::complex<double>* y, fortran_int_t incy ) {
BLAS_ZAXPY( &n, &a, x, &incx, y, &incy );
}
@@ -209,7 +207,7 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
VectorX >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline void copy( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
+inline void copy( int n, const float* x, int incx, float* y, int incy ) {
cblas_scopy( n, x, incx, y, incy );
}
@@ -70,8 +69,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline void copy( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+inline void copy( int n, const double* x, int incx, double* y, int incy ) {
cblas_dcopy( n, x, incx, y, incy );
}
@@ -80,9 +78,8 @@
// * CBLAS backend, and
// * complex<float> value-type.
//
-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 ) {
+inline void copy( int n, const std::complex<float>* x, int incx,
+ std::complex<float>* y, int incy ) {
cblas_ccopy( n, x, incx, y, incy );
}
@@ -91,9 +88,8 @@
// * CBLAS backend, and
// * complex<double> value-type.
//
-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 ) {
+inline void copy( int n, const std::complex<double>* x, int incx,
+ std::complex<double>* y, int incy ) {
cblas_zcopy( n, x, incx, y, incy );
}
@@ -103,8 +99,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline void copy( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
+inline void copy( int n, const float* x, int incx, float* y, int incy ) {
cublasScopy( n, x, incx, y, incy );
}
@@ -113,8 +108,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline void copy( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+inline void copy( int n, const double* x, int incx, double* y, int incy ) {
cublasDcopy( n, x, incx, y, incy );
}
@@ -123,9 +117,8 @@
// * CUBLAS backend, and
// * complex<float> value-type.
//
-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 ) {
+inline void copy( int n, const std::complex<float>* x, int incx,
+ std::complex<float>* y, int incy ) {
cublasCcopy( n, x, incx, y, incy );
}
@@ -134,9 +127,8 @@
// * CUBLAS backend, and
// * complex<double> value-type.
//
-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 ) {
+inline void copy( int n, const std::complex<double>* x, int incx,
+ std::complex<double>* y, int incy ) {
// NOT FOUND();
}
@@ -146,8 +138,8 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline void copy( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx, float* y, const std::ptrdiff_t incy ) {
+inline void copy( fortran_int_t n, const float* x, fortran_int_t incx,
+ float* y, fortran_int_t incy ) {
BLAS_SCOPY( &n, x, &incx, y, &incy );
}
@@ -156,8 +148,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline void copy( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+inline void copy( fortran_int_t n, const double* x, fortran_int_t incx,
+ double* y, fortran_int_t incy ) {
BLAS_DCOPY( &n, x, &incx, y, &incy );
}
@@ -166,9 +158,8 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<float> value-type.
//
-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 ) {
+inline void copy( fortran_int_t n, const std::complex<float>* x,
+ fortran_int_t incx, std::complex<float>* y, fortran_int_t incy ) {
BLAS_CCOPY( &n, x, &incx, y, &incy );
}
@@ -177,9 +168,8 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<double> value-type.
//
-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 ) {
+inline void copy( fortran_int_t n, const std::complex<double>* x,
+ fortran_int_t incx, std::complex<double>* y, fortran_int_t incy ) {
BLAS_ZCOPY( &n, x, &incx, y, &incy );
}
@@ -208,7 +198,7 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
VectorX >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,9 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline float dot( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy ) {
+inline float dot( int n, const float* x, int incx, const float* y, int incy ) {
return cblas_sdot( n, x, incx, y, incy );
}
@@ -71,9 +69,8 @@
// * CBLAS backend, and
// * double value-type.
//
-inline double dot( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy ) {
+inline double dot( int n, const double* x, int incx, const double* y,
+ int incy ) {
return cblas_ddot( n, x, incx, y, incy );
}
@@ -83,9 +80,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline float dot( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy ) {
+inline float dot( int n, const float* x, int incx, const float* y, int incy ) {
return cublasSdot( n, x, incx, y, incy );
}
@@ -94,9 +89,8 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline double dot( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy ) {
+inline double dot( int n, const double* x, int incx, const double* y,
+ int incy ) {
return cublasDdot( n, x, incx, y, incy );
}
@@ -106,9 +100,8 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline float dot( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy ) {
+inline float dot( fortran_int_t n, const float* x, fortran_int_t incx,
+ const float* y, fortran_int_t incy ) {
return BLAS_SDOT( &n, x, &incx, y, &incy );
}
@@ -117,9 +110,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline double dot( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy ) {
+inline double dot( fortran_int_t n, const double* x, fortran_int_t incx,
+ const double* y, fortran_int_t incy ) {
return BLAS_DDOT( &n, x, &incx, y, &incy );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,9 +60,8 @@
// * CBLAS backend, and
// * complex<float> value-type.
//
-inline std::complex<float> 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 ) {
+inline std::complex<float> dotc( int n, const std::complex<float>* x,
+ int incx, const std::complex<float>* y, int incy ) {
std::complex<float> result;
cblas_cdotc_sub( n, x, incx, y, incy, &result );
return result;
@@ -73,9 +72,8 @@
// * CBLAS backend, and
// * complex<double> value-type.
//
-inline std::complex<double> 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 ) {
+inline std::complex<double> dotc( int n, const std::complex<double>* x,
+ int incx, const std::complex<double>* y, int incy ) {
std::complex<double> result;
cblas_zdotc_sub( n, x, incx, y, incy, &result );
return result;
@@ -87,9 +85,8 @@
// * CUBLAS backend, and
// * complex<float> value-type.
//
-inline std::complex<float> 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 ) {
+inline std::complex<float> dotc( int n, const std::complex<float>* x,
+ int incx, const std::complex<float>* y, int incy ) {
return cublasCdotc( n, x, incx, y, incy );
}
@@ -98,9 +95,8 @@
// * CUBLAS backend, and
// * complex<double> value-type.
//
-inline std::complex<double> 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 ) {
+inline std::complex<double> dotc( int n, const std::complex<double>* x,
+ int incx, const std::complex<double>* y, int incy ) {
return // NOT FOUND();
}
@@ -110,9 +106,9 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<float> value-type.
//
-inline std::complex<float> 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 ) {
+inline std::complex<float> dotc( fortran_int_t n,
+ const std::complex<float>* x, fortran_int_t incx,
+ const std::complex<float>* y, fortran_int_t incy ) {
return BLAS_CDOTC( &n, x, &incx, y, &incy );
}
@@ -121,9 +117,9 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<double> value-type.
//
-inline std::complex<double> 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 ) {
+inline std::complex<double> dotc( fortran_int_t n,
+ const std::complex<double>* x, fortran_int_t incx,
+ const std::complex<double>* y, fortran_int_t incy ) {
return BLAS_ZDOTC( &n, x, &incx, y, &incy );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,9 +60,8 @@
// * CBLAS backend, and
// * complex<float> value-type.
//
-inline std::complex<float> 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 ) {
+inline std::complex<float> dotu( int n, const std::complex<float>* x,
+ int incx, const std::complex<float>* y, int incy ) {
std::complex<float> result;
cblas_cdotu_sub( n, x, incx, y, incy, &result );
return result;
@@ -73,9 +72,8 @@
// * CBLAS backend, and
// * complex<double> value-type.
//
-inline std::complex<double> 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 ) {
+inline std::complex<double> dotu( int n, const std::complex<double>* x,
+ int incx, const std::complex<double>* y, int incy ) {
std::complex<double> result;
cblas_zdotu_sub( n, x, incx, y, incy, &result );
return result;
@@ -87,9 +85,8 @@
// * CUBLAS backend, and
// * complex<float> value-type.
//
-inline std::complex<float> 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 ) {
+inline std::complex<float> dotu( int n, const std::complex<float>* x,
+ int incx, const std::complex<float>* y, int incy ) {
return cublasCdotu( n, x, incx, y, incy );
}
@@ -98,9 +95,8 @@
// * CUBLAS backend, and
// * complex<double> value-type.
//
-inline std::complex<double> 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 ) {
+inline std::complex<double> dotu( int n, const std::complex<double>* x,
+ int incx, const std::complex<double>* y, int incy ) {
return cublasZdotu( n, x, incx, y, incy );
}
@@ -110,9 +106,9 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<float> value-type.
//
-inline std::complex<float> 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 ) {
+inline std::complex<float> dotu( fortran_int_t n,
+ const std::complex<float>* x, fortran_int_t incx,
+ const std::complex<float>* y, fortran_int_t incy ) {
return BLAS_CDOTU( &n, x, &incx, y, &incy );
}
@@ -121,9 +117,9 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<double> value-type.
//
-inline std::complex<double> 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 ) {
+inline std::complex<double> dotu( fortran_int_t n,
+ const std::complex<double>* x, fortran_int_t incx,
+ const std::complex<double>* y, fortran_int_t incy ) {
return BLAS_ZDOTU( &n, x, &incx, y, &incy );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline float nrm2( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx ) {
+inline float nrm2( int n, const float* x, int incx ) {
return cblas_snrm2( n, x, incx );
}
@@ -70,8 +69,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline double nrm2( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx ) {
+inline double nrm2( int n, const double* x, int incx ) {
return cblas_dnrm2( n, x, incx );
}
@@ -81,8 +79,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline float nrm2( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx ) {
+inline float nrm2( int n, const float* x, int incx ) {
return cublasSnrm2( n, x, incx );
}
@@ -91,8 +88,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline double nrm2( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx ) {
+inline double nrm2( int n, const double* x, int incx ) {
return cublasDnrm2( n, x, incx );
}
@@ -102,8 +98,7 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline float nrm2( const std::ptrdiff_t n, const float* x,
- const std::ptrdiff_t incx ) {
+inline float nrm2( fortran_int_t n, const float* x, fortran_int_t incx ) {
return BLAS_SNRM2( &n, x, &incx );
}
@@ -112,8 +107,7 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline double nrm2( const std::ptrdiff_t n, const double* x,
- const std::ptrdiff_t incx ) {
+inline double nrm2( fortran_int_t n, const double* x, fortran_int_t incx ) {
return BLAS_DNRM2( &n, x, &incx );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,9 +60,8 @@
// * CBLAS backend, and
// * float value-type.
//
-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 ) {
+inline void rot( int n, const float* x, int incx, float* y, int incy, float c,
+ float s ) {
cblas_srot( n, x, incx, y, incy, c, s );
}
@@ -71,9 +70,8 @@
// * CBLAS backend, and
// * double value-type.
//
-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 ) {
+inline void rot( int n, const double* x, int incx, double* y, int incy,
+ double c, double s ) {
cblas_drot( n, x, incx, y, incy, c, s );
}
@@ -83,9 +81,8 @@
// * CUBLAS backend, and
// * float value-type.
//
-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 ) {
+inline void rot( int n, const float* x, int incx, float* y, int incy, float c,
+ float s ) {
cublasSrot( n, x, incx, y, incy, c, s );
}
@@ -94,9 +91,8 @@
// * CUBLAS backend, and
// * double value-type.
//
-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 ) {
+inline void rot( int n, const double* x, int incx, double* y, int incy,
+ double c, double s ) {
cublasDrot( n, x, incx, y, incy, c, s );
}
@@ -106,9 +102,8 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-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 ) {
+inline void rot( fortran_int_t n, const float* x, fortran_int_t incx,
+ float* y, fortran_int_t incy, float c, float s ) {
BLAS_SROT( &n, x, &incx, y, &incy, &c, &s );
}
@@ -117,9 +112,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-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 ) {
+inline void rot( fortran_int_t n, const double* x, fortran_int_t incx,
+ double* y, fortran_int_t incy, double c, double s ) {
BLAS_DROT( &n, x, &incx, y, &incy, &c, &s );
}
@@ -149,7 +143,7 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
VectorX >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::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/rotm.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/blas/level1/rotm.hpp 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,8 @@
// * CBLAS backend, and
// * float value-type.
//
-inline void rotm( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
- float* y, const std::ptrdiff_t incy, float* param ) {
+inline void rotm( int n, float* x, int incx, float* y, int incy,
+ float* param ) {
cblas_srotm( n, x, incx, y, incy, param );
}
@@ -70,8 +70,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline void rotm( const std::ptrdiff_t n, double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
+inline void rotm( int n, double* x, int incx, double* y, int incy,
double* param ) {
cblas_drotm( n, x, incx, y, incy, param );
}
@@ -82,8 +81,8 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline void rotm( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
- float* y, const std::ptrdiff_t incy, float* param ) {
+inline void rotm( int n, float* x, int incx, float* y, int incy,
+ float* param ) {
cublasSrotm( n, x, incx, y, incy, param );
}
@@ -92,8 +91,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline void rotm( const std::ptrdiff_t n, double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
+inline void rotm( int n, double* x, int incx, double* y, int incy,
double* param ) {
cublasDrotm( n, x, incx, y, incy, param );
}
@@ -104,8 +102,8 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline void rotm( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
- float* y, const std::ptrdiff_t incy, float* param ) {
+inline void rotm( fortran_int_t n, float* x, fortran_int_t incx, float* y,
+ fortran_int_t incy, float* param ) {
BLAS_SROTM( &n, x, &incx, y, &incy, param );
}
@@ -114,9 +112,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline void rotm( const std::ptrdiff_t n, double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy,
- double* param ) {
+inline void rotm( fortran_int_t n, double* x, fortran_int_t incx, double* y,
+ fortran_int_t incy, double* param ) {
BLAS_DROTM( &n, x, &incx, y, &incy, param );
}
@@ -142,17 +139,17 @@
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
static return_type invoke( const std::ptrdiff_t n, VectorX& x,
- const std::ptrdiff_t incx, VectorY& y, const std::ptrdiff_t incy,
- VectorPARAM& param ) {
+ const std::ptrdiff_t incx, VectorY& y,
+ const std::ptrdiff_t incy, VectorPARAM& param ) {
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
VectorX >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
VectorX >::type >::type, typename remove_const<
typename value< VectorPARAM >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorPARAM >::value ) );
+ 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) );
}
@@ -174,8 +171,9 @@
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
-rotm( const std::ptrdiff_t n, VectorX& x, const std::ptrdiff_t incx,
- VectorY& y, const std::ptrdiff_t incy, VectorPARAM& param ) {
+rotm( const std::ptrdiff_t n, VectorX& x,
+ const std::ptrdiff_t incx, VectorY& y,
+ const std::ptrdiff_t incy, VectorPARAM& param ) {
rotm_impl< typename value< VectorX >::type >::invoke( n, x, incx, y,
incy, param );
}
@@ -189,8 +187,8 @@
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
rotm( const std::ptrdiff_t n, const VectorX& x,
- const std::ptrdiff_t incx, VectorY& y, const std::ptrdiff_t incy,
- VectorPARAM& param ) {
+ const std::ptrdiff_t incx, VectorY& y,
+ const std::ptrdiff_t incy, VectorPARAM& param ) {
rotm_impl< typename value< VectorX >::type >::invoke( n, x, incx, y,
incy, param );
}
@@ -203,8 +201,9 @@
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
-rotm( const std::ptrdiff_t n, VectorX& x, const std::ptrdiff_t incx,
- const VectorY& y, const std::ptrdiff_t incy, VectorPARAM& param ) {
+rotm( const std::ptrdiff_t n, VectorX& x,
+ const std::ptrdiff_t incx, const VectorY& y,
+ const std::ptrdiff_t incy, VectorPARAM& param ) {
rotm_impl< typename value< VectorX >::type >::invoke( n, x, incx, y,
incy, param );
}
@@ -232,8 +231,9 @@
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
-rotm( const std::ptrdiff_t n, VectorX& x, const std::ptrdiff_t incx,
- VectorY& y, const std::ptrdiff_t incy, const VectorPARAM& param ) {
+rotm( const std::ptrdiff_t n, VectorX& x,
+ const std::ptrdiff_t incx, VectorY& y,
+ const std::ptrdiff_t incy, const VectorPARAM& param ) {
rotm_impl< typename value< VectorX >::type >::invoke( n, x, incx, y,
incy, param );
}
@@ -247,8 +247,8 @@
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
rotm( const std::ptrdiff_t n, const VectorX& x,
- const std::ptrdiff_t incx, VectorY& y, const std::ptrdiff_t incy,
- const VectorPARAM& param ) {
+ const std::ptrdiff_t incx, VectorY& y,
+ const std::ptrdiff_t incy, const VectorPARAM& param ) {
rotm_impl< typename value< VectorX >::type >::invoke( n, x, incx, y,
incy, param );
}
@@ -261,9 +261,9 @@
//
template< typename VectorX, typename VectorY, typename VectorPARAM >
inline typename rotm_impl< typename value< VectorX >::type >::return_type
-rotm( const std::ptrdiff_t n, VectorX& x, const std::ptrdiff_t incx,
- const VectorY& y, const std::ptrdiff_t incy,
- const VectorPARAM& param ) {
+rotm( const std::ptrdiff_t n, VectorX& x,
+ const std::ptrdiff_t incx, const VectorY& y,
+ const std::ptrdiff_t incy, const VectorPARAM& param ) {
rotm_impl< typename value< VectorX >::type >::invoke( n, x, incx, y,
incy, param );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline void rotmg( float& d1, float& d2, float& x1, const float y1,
- float* sparam ) {
+inline void rotmg( float& d1, float& d2, float& x1, float y1, float* sparam ) {
cblas_srotmg( &d1, &d2, &x1, &y1, sparam );
}
@@ -70,7 +69,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline void rotmg( double& d1, double& d2, double& x1, const double y1,
+inline void rotmg( double& d1, double& d2, double& x1, double y1,
double* dparam ) {
cblas_drotmg( &d1, &d2, &x1, &y1, dparam );
}
@@ -81,8 +80,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline void rotmg( float& d1, float& d2, float& x1, const float y1,
- float* sparam ) {
+inline void rotmg( float& d1, float& d2, float& x1, float y1, float* sparam ) {
cublasSrotmg( &d1, &d2, &x1, &y1, sparam );
}
@@ -91,7 +89,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline void rotmg( double& d1, double& d2, double& x1, const double y1,
+inline void rotmg( double& d1, double& d2, double& x1, double y1,
double* dparam ) {
cublasDrotmg( &d1, &d2, &x1, &y1, dparam );
}
@@ -102,8 +100,7 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline void rotmg( float& d1, float& d2, float& x1, const float y1,
- float* sparam ) {
+inline void rotmg( float& d1, float& d2, float& x1, float y1, float* sparam ) {
BLAS_SROTMG( &d1, &d2, &x1, &y1, sparam );
}
@@ -112,7 +109,7 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline void rotmg( double& d1, double& d2, double& x1, const double y1,
+inline void rotmg( double& d1, double& d2, double& x1, double y1,
double* dparam ) {
BLAS_DROTMG( &d1, &d2, &x1, &y1, dparam );
}
@@ -140,7 +137,7 @@
template< typename VectorDPARAM >
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorDPARAM >::value) );
detail::rotmg( d1, d2, x1, y1, begin_value(dparam) );
}
};
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline void scal( const std::ptrdiff_t n, const float a, float* x,
- const std::ptrdiff_t incx ) {
+inline void scal( int n, float a, float* x, int incx ) {
cblas_sscal( n, a, x, incx );
}
@@ -70,8 +69,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline void scal( const std::ptrdiff_t n, const double a, double* x,
- const std::ptrdiff_t incx ) {
+inline void scal( int n, double a, double* x, int incx ) {
cblas_dscal( n, a, x, incx );
}
@@ -80,8 +78,8 @@
// * CBLAS backend, and
// * complex<float> value-type.
//
-inline void scal( const std::ptrdiff_t n, const std::complex<float> a,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void scal( int n, std::complex<float> a, std::complex<float>* x,
+ int incx ) {
cblas_cscal( n, &a, x, incx );
}
@@ -90,8 +88,8 @@
// * CBLAS backend, and
// * complex<double> value-type.
//
-inline void scal( const std::ptrdiff_t n, const std::complex<double> a,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void scal( int n, std::complex<double> a, std::complex<double>* x,
+ int incx ) {
cblas_zscal( n, &a, x, incx );
}
@@ -101,8 +99,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline void scal( const std::ptrdiff_t n, const float a, float* x,
- const std::ptrdiff_t incx ) {
+inline void scal( int n, float a, float* x, int incx ) {
cublasSscal( n, a, x, incx );
}
@@ -111,8 +108,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline void scal( const std::ptrdiff_t n, const double a, double* x,
- const std::ptrdiff_t incx ) {
+inline void scal( int n, double a, double* x, int incx ) {
cublasDscal( n, a, x, incx );
}
@@ -121,8 +117,8 @@
// * CUBLAS backend, and
// * complex<float> value-type.
//
-inline void scal( const std::ptrdiff_t n, const std::complex<float> a,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void scal( int n, std::complex<float> a, std::complex<float>* x,
+ int incx ) {
cublasCscal( n, a, x, incx );
}
@@ -131,8 +127,8 @@
// * CUBLAS backend, and
// * complex<double> value-type.
//
-inline void scal( const std::ptrdiff_t n, const std::complex<double> a,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void scal( int n, std::complex<double> a, std::complex<double>* x,
+ int incx ) {
cublasZscal( n, a, x, incx );
}
@@ -142,8 +138,7 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline void scal( const std::ptrdiff_t n, const float a, float* x,
- const std::ptrdiff_t incx ) {
+inline void scal( fortran_int_t n, float a, float* x, fortran_int_t incx ) {
BLAS_SSCAL( &n, &a, x, &incx );
}
@@ -152,8 +147,7 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline void scal( const std::ptrdiff_t n, const double a, double* x,
- const std::ptrdiff_t incx ) {
+inline void scal( fortran_int_t n, double a, double* x, fortran_int_t incx ) {
BLAS_DSCAL( &n, &a, x, &incx );
}
@@ -162,8 +156,8 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<float> value-type.
//
-inline void scal( const std::ptrdiff_t n, const std::complex<float> a,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void scal( fortran_int_t n, std::complex<float> a,
+ std::complex<float>* x, fortran_int_t incx ) {
BLAS_CSCAL( &n, &a, x, &incx );
}
@@ -172,8 +166,8 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<double> value-type.
//
-inline void scal( const std::ptrdiff_t n, const std::complex<double> a,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void scal( fortran_int_t n, std::complex<double> a,
+ std::complex<double>* x, fortran_int_t incx ) {
BLAS_ZSCAL( &n, &a, x, &incx );
}
@@ -199,7 +193,7 @@
//
template< typename VectorX >
static return_type invoke( const value_type a, VectorX& x ) {
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
+ 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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,9 +60,8 @@
// * CBLAS backend, and
// * double value-type.
//
-inline double sdot( const std::ptrdiff_t n, const float* sx,
- const std::ptrdiff_t incx, const float* sy,
- const std::ptrdiff_t incy ) {
+inline double sdot( int n, const float* sx, int incx, const float* sy,
+ int incy ) {
return cblas_dsdot( n, sx, incx, sy, incy );
}
@@ -72,9 +71,8 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline double sdot( const std::ptrdiff_t n, const float* sx,
- const std::ptrdiff_t incx, const float* sy,
- const std::ptrdiff_t incy ) {
+inline double sdot( int n, const float* sx, int incx, const float* sy,
+ int incy ) {
return // NOT FOUND();
}
@@ -84,9 +82,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline double sdot( const std::ptrdiff_t n, const float* sx,
- const std::ptrdiff_t incx, const float* sy,
- const std::ptrdiff_t incy ) {
+inline double sdot( fortran_int_t n, const float* sx, fortran_int_t incx,
+ const float* sy, fortran_int_t incy ) {
return BLAS_DSDOT( &n, sx, &incx, 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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -60,8 +60,7 @@
// * CBLAS backend, and
// * float value-type.
//
-inline void swap( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
- float* y, const std::ptrdiff_t incy ) {
+inline void swap( int n, float* x, int incx, float* y, int incy ) {
cblas_sswap( n, x, incx, y, incy );
}
@@ -70,8 +69,7 @@
// * CBLAS backend, and
// * double value-type.
//
-inline void swap( const std::ptrdiff_t n, double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+inline void swap( int n, double* x, int incx, double* y, int incy ) {
cblas_dswap( n, x, incx, y, incy );
}
@@ -80,9 +78,8 @@
// * CBLAS backend, and
// * complex<float> value-type.
//
-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 ) {
+inline void swap( int n, std::complex<float>* x, int incx,
+ std::complex<float>* y, int incy ) {
cblas_cswap( n, x, incx, y, incy );
}
@@ -91,9 +88,8 @@
// * CBLAS backend, and
// * complex<double> value-type.
//
-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 ) {
+inline void swap( int n, std::complex<double>* x, int incx,
+ std::complex<double>* y, int incy ) {
cblas_zswap( n, x, incx, y, incy );
}
@@ -103,8 +99,7 @@
// * CUBLAS backend, and
// * float value-type.
//
-inline void swap( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
- float* y, const std::ptrdiff_t incy ) {
+inline void swap( int n, float* x, int incx, float* y, int incy ) {
cublasSswap( n, x, incx, y, incy );
}
@@ -113,8 +108,7 @@
// * CUBLAS backend, and
// * double value-type.
//
-inline void swap( const std::ptrdiff_t n, double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+inline void swap( int n, double* x, int incx, double* y, int incy ) {
cublasDswap( n, x, incx, y, incy );
}
@@ -123,9 +117,8 @@
// * CUBLAS backend, and
// * complex<float> value-type.
//
-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 ) {
+inline void swap( int n, std::complex<float>* x, int incx,
+ std::complex<float>* y, int incy ) {
cublasCswap( n, x, incx, y, incy );
}
@@ -134,9 +127,8 @@
// * CUBLAS backend, and
// * complex<double> value-type.
//
-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 ) {
+inline void swap( int n, std::complex<double>* x, int incx,
+ std::complex<double>* y, int incy ) {
// NOT FOUND();
}
@@ -146,8 +138,8 @@
// * netlib-compatible BLAS backend (the default), and
// * float value-type.
//
-inline void swap( const std::ptrdiff_t n, float* x, const std::ptrdiff_t incx,
- float* y, const std::ptrdiff_t incy ) {
+inline void swap( fortran_int_t n, float* x, fortran_int_t incx, float* y,
+ fortran_int_t incy ) {
BLAS_SSWAP( &n, x, &incx, y, &incy );
}
@@ -156,8 +148,8 @@
// * netlib-compatible BLAS backend (the default), and
// * double value-type.
//
-inline void swap( const std::ptrdiff_t n, double* x,
- const std::ptrdiff_t incx, double* y, const std::ptrdiff_t incy ) {
+inline void swap( fortran_int_t n, double* x, fortran_int_t incx, double* y,
+ fortran_int_t incy ) {
BLAS_DSWAP( &n, x, &incx, y, &incy );
}
@@ -166,9 +158,8 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<float> value-type.
//
-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 ) {
+inline void swap( fortran_int_t n, std::complex<float>* x, fortran_int_t incx,
+ std::complex<float>* y, fortran_int_t incy ) {
BLAS_CSWAP( &n, x, &incx, y, &incy );
}
@@ -177,9 +168,8 @@
// * netlib-compatible BLAS backend (the default), and
// * complex<double> value-type.
//
-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 ) {
+inline void swap( fortran_int_t n, std::complex<double>* x,
+ fortran_int_t incx, std::complex<double>* y, fortran_int_t incy ) {
BLAS_ZSWAP( &n, x, &incx, y, &incy );
}
@@ -208,8 +198,8 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
VectorX >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value ) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::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) );
}
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -15,6 +15,7 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GBMV_HPP
#include <boost/assert.hpp>
+#include <boost/numeric/bindings/bandwidth.hpp
#include <boost/numeric/bindings/begin.hpp>
#include <boost/numeric/bindings/blas/detail/default_order.hpp>
#include <boost/numeric/bindings/is_column_major.hpp>
@@ -64,11 +65,9 @@
// * float value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku, float alpha,
+ const float* a, int lda, const float* x, int incx, float beta,
+ float* y, int incy ) {
cblas_sgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy );
}
@@ -79,11 +78,9 @@
// * double value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku, double alpha,
+ const double* a, int lda, const double* x, int incx, double beta,
+ double* y, int incy ) {
cblas_dgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy );
}
@@ -94,13 +91,10 @@
// * complex<float> value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* x, int incx, std::complex<float> beta,
+ std::complex<float>* y, int incy ) {
cblas_cgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, kl, ku, &alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -111,13 +105,10 @@
// * complex<double> value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* x, int incx, std::complex<double> beta,
+ std::complex<double>* y, int incy ) {
cblas_zgbmv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, kl, ku, &alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -129,11 +120,9 @@
// * float value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku, float alpha,
+ const float* a, int lda, const float* x, int incx, float beta,
+ float* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x,
incx, beta, y, incy );
@@ -145,11 +134,9 @@
// * double value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku, double alpha,
+ const double* a, int lda, const double* x, int incx, double beta,
+ double* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -160,13 +147,10 @@
// * complex<float> value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* x, int incx, std::complex<float> beta,
+ std::complex<float>* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x,
incx, beta, y, incy );
@@ -178,13 +162,10 @@
// * complex<double> value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, int m, int n, int kl, int ku,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* x, int incx, std::complex<double> beta,
+ std::complex<double>* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -196,11 +177,10 @@
// * float value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ fortran_int_t kl, fortran_int_t ku, float alpha, const float* a,
+ fortran_int_t lda, const float* x, fortran_int_t incx, float beta,
+ float* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
&lda, x, &incx, &beta, y, &incy );
@@ -212,11 +192,10 @@
// * double value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ fortran_int_t kl, fortran_int_t ku, double alpha, const double* a,
+ fortran_int_t lda, const double* x, fortran_int_t incx, double beta,
+ double* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
&lda, x, &incx, &beta, y, &incy );
@@ -228,13 +207,12 @@
// * complex<float> value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ fortran_int_t kl, fortran_int_t ku, std::complex<float> alpha,
+ const std::complex<float>* a, fortran_int_t lda,
+ const std::complex<float>* x, fortran_int_t incx,
+ std::complex<float> beta, std::complex<float>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
&lda, x, &incx, &beta, y, &incy );
@@ -246,13 +224,12 @@
// * complex<double> value-type.
//
template< typename Order, typename Trans >
-inline void gbmv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void gbmv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ fortran_int_t kl, fortran_int_t ku, std::complex<double> alpha,
+ const std::complex<double>* a, fortran_int_t lda,
+ const std::complex<double>* x, fortran_int_t incx,
+ std::complex<double> beta, std::complex<double>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a,
&lda, x, &incx, &beta, y, &incy );
@@ -279,8 +256,7 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixA, typename VectorX, typename VectorY >
- static return_type invoke( const std::ptrdiff_t kl,
- const std::ptrdiff_t ku, const value_type alpha, const MatrixA& a,
+ 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;
@@ -290,9 +266,11 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixA >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
detail::gbmv( order(), trans(), size_row_op(a, trans()),
- size_column_op(a, trans()), kl, ku, alpha, begin_value(a),
+ size_column_op(a, trans()), bandwidth_lower_op(a, trans()),
+ bandwidth_upper_op(a, trans()), alpha, begin_value(a),
stride_major(a), begin_value(x), stride(x), beta,
begin_value(y), stride(y) );
}
@@ -312,12 +290,11 @@
//
template< typename MatrixA, typename VectorX, typename VectorY >
inline typename gbmv_impl< typename value< MatrixA >::type >::return_type
-gbmv( const std::ptrdiff_t kl, const std::ptrdiff_t ku,
- const typename value< MatrixA >::type alpha, const MatrixA& a,
+gbmv( const typename value< MatrixA >::type alpha, const MatrixA& a,
const VectorX& x, const typename value< MatrixA >::type beta,
VectorY& y ) {
- gbmv_impl< typename value< MatrixA >::type >::invoke( kl, ku, alpha,
- a, x, beta, y );
+ gbmv_impl< typename value< MatrixA >::type >::invoke( alpha, a, x,
+ beta, y );
}
//
@@ -326,12 +303,11 @@
//
template< typename MatrixA, typename VectorX, typename VectorY >
inline typename gbmv_impl< typename value< MatrixA >::type >::return_type
-gbmv( const std::ptrdiff_t kl, const std::ptrdiff_t ku,
- const typename value< MatrixA >::type alpha, const MatrixA& a,
+gbmv( const typename value< MatrixA >::type alpha, const MatrixA& a,
const VectorX& x, const typename value< MatrixA >::type beta,
const VectorY& y ) {
- gbmv_impl< typename value< MatrixA >::type >::invoke( kl, ku, alpha,
- a, x, beta, y );
+ gbmv_impl< typename value< MatrixA >::type >::invoke( alpha, a, x,
+ beta, y );
}
} // namespace blas
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,10 +64,8 @@
// * float value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, float alpha, const float* a,
+ int lda, const float* x, int incx, float beta, float* y, int incy ) {
cblas_sgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, alpha, a, lda, x, incx, beta, y, incy );
}
@@ -78,10 +76,9 @@
// * double value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, double alpha, const double* a,
+ int lda, const double* x, int incx, double beta, double* y,
+ int incy ) {
cblas_dgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, alpha, a, lda, x, incx, beta, y, incy );
}
@@ -92,12 +89,10 @@
// * complex<float> value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, const std::complex<float>* x,
+ int incx, std::complex<float> beta, std::complex<float>* y,
+ int incy ) {
cblas_cgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, &alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -108,12 +103,10 @@
// * complex<double> value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, std::complex<double> alpha,
+ const std::complex<double>* a, int lda, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
cblas_zgemv( cblas_option< Order >::value, cblas_option< Trans >::value,
m, n, &alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -125,10 +118,8 @@
// * float value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, float alpha, const float* a,
+ int lda, const float* x, int incx, float beta, float* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
beta, y, incy );
@@ -140,10 +131,9 @@
// * double value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, double alpha, const double* a,
+ int lda, const double* x, int incx, double beta, double* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
beta, y, incy );
@@ -155,12 +145,10 @@
// * complex<float> value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, const std::complex<float>* x,
+ int incx, std::complex<float> beta, std::complex<float>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
beta, y, incy );
@@ -172,12 +160,10 @@
// * complex<double> value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, int m, int n, std::complex<double> alpha,
+ const std::complex<double>* a, int lda, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasZgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx,
beta, y, incy );
@@ -190,10 +176,9 @@
// * float value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n, float alpha,
+ const float* a, fortran_int_t lda, const float* x, fortran_int_t incx,
+ float beta, float* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -205,10 +190,9 @@
// * double value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ double alpha, const double* a, fortran_int_t lda, const double* x,
+ fortran_int_t incx, double beta, double* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -220,12 +204,11 @@
// * complex<float> value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, const std::complex<float>* x, fortran_int_t incx,
+ std::complex<float> beta, std::complex<float>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -237,12 +220,11 @@
// * complex<double> value-type.
//
template< typename Order, typename Trans >
-inline void gemv( Order, Trans, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void gemv( Order, Trans, fortran_int_t m, fortran_int_t n,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, const std::complex<double>* x, fortran_int_t incx,
+ std::complex<double> beta, std::complex<double>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -286,7 +268,8 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixA >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -63,10 +63,8 @@
// * float value-type.
//
template< typename Order >
-inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const float alpha, const float* x, const std::ptrdiff_t incx,
- const float* y, const std::ptrdiff_t incy, float* a,
- const std::ptrdiff_t lda ) {
+inline void ger( Order, int m, int n, float alpha, const float* x, int incx,
+ const float* y, int incy, float* a, int lda ) {
cblas_sger( cblas_option< Order >::value, m, n, alpha, x, incx, y, incy,
a, lda );
}
@@ -77,10 +75,8 @@
// * double value-type.
//
template< typename Order >
-inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const double alpha, const double* x, const std::ptrdiff_t incx,
- const double* y, const std::ptrdiff_t incy, double* a,
- const std::ptrdiff_t lda ) {
+inline void ger( Order, int m, int n, double alpha, const double* x, int incx,
+ const double* y, int incy, double* a, int lda ) {
cblas_dger( cblas_option< Order >::value, m, n, alpha, x, incx, y, incy,
a, lda );
}
@@ -92,10 +88,8 @@
// * float value-type.
//
template< typename Order >
-inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const float alpha, const float* x, const std::ptrdiff_t incx,
- const float* y, const std::ptrdiff_t incy, float* a,
- const std::ptrdiff_t lda ) {
+inline void ger( Order, int m, int n, float alpha, const float* x, int incx,
+ const float* y, int incy, float* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSger( m, n, alpha, x, incx, y, incy, a, lda );
}
@@ -106,10 +100,8 @@
// * double value-type.
//
template< typename Order >
-inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const double alpha, const double* x, const std::ptrdiff_t incx,
- const double* y, const std::ptrdiff_t incy, double* a,
- const std::ptrdiff_t lda ) {
+inline void ger( Order, int m, int n, double alpha, const double* x, int incx,
+ const double* y, int incy, double* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDger( m, n, alpha, x, incx, y, incy, a, lda );
}
@@ -121,10 +113,9 @@
// * float value-type.
//
template< typename Order >
-inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const float alpha, const float* x, const std::ptrdiff_t incx,
- const float* y, const std::ptrdiff_t incy, float* a,
- const std::ptrdiff_t lda ) {
+inline void ger( Order, fortran_int_t m, fortran_int_t n, float alpha,
+ const float* x, fortran_int_t incx, const float* y,
+ fortran_int_t incy, float* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SGER( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
}
@@ -135,10 +126,9 @@
// * double value-type.
//
template< typename Order >
-inline void ger( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const double alpha, const double* x, const std::ptrdiff_t incx,
- const double* y, const std::ptrdiff_t incy, double* a,
- const std::ptrdiff_t lda ) {
+inline void ger( Order, fortran_int_t m, fortran_int_t n, double alpha,
+ const double* x, fortran_int_t incx, const double* y,
+ fortran_int_t incy, double* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DGER( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
}
@@ -173,7 +163,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -63,11 +63,9 @@
// * complex<float> value-type.
//
template< typename Order >
-inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void gerc( Order, int m, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* a, int lda ) {
cblas_cgerc( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
a, lda );
}
@@ -78,11 +76,10 @@
// * complex<double> value-type.
//
template< typename Order >
-inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void gerc( Order, int m, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* a,
+ int lda ) {
cblas_zgerc( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
a, lda );
}
@@ -94,11 +91,9 @@
// * complex<float> value-type.
//
template< typename Order >
-inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void gerc( Order, int m, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCgerc( m, n, alpha, x, incx, y, incy, a, lda );
}
@@ -109,11 +104,10 @@
// * complex<double> value-type.
//
template< typename Order >
-inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void gerc( Order, int m, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* a,
+ int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -125,11 +119,10 @@
// * complex<float> value-type.
//
template< typename Order >
-inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void gerc( Order, fortran_int_t m, fortran_int_t n,
+ std::complex<float> alpha, const std::complex<float>* x,
+ fortran_int_t incx, const std::complex<float>* y, fortran_int_t incy,
+ std::complex<float>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CGERC( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
}
@@ -140,11 +133,10 @@
// * complex<double> value-type.
//
template< typename Order >
-inline void gerc( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void gerc( Order, fortran_int_t m, fortran_int_t n,
+ std::complex<double> alpha, const std::complex<double>* x,
+ fortran_int_t incx, const std::complex<double>* y, fortran_int_t incy,
+ std::complex<double>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZGERC( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
}
@@ -179,7 +171,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -63,11 +63,9 @@
// * complex<float> value-type.
//
template< typename Order >
-inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void geru( Order, int m, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* a, int lda ) {
cblas_cgeru( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
a, lda );
}
@@ -78,11 +76,10 @@
// * complex<double> value-type.
//
template< typename Order >
-inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void geru( Order, int m, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* a,
+ int lda ) {
cblas_zgeru( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy,
a, lda );
}
@@ -94,11 +91,9 @@
// * complex<float> value-type.
//
template< typename Order >
-inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void geru( Order, int m, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCgeru( m, n, alpha, x, incx, y, incy, a, lda );
}
@@ -109,11 +104,10 @@
// * complex<double> value-type.
//
template< typename Order >
-inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void geru( Order, int m, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* a,
+ int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -125,11 +119,10 @@
// * complex<float> value-type.
//
template< typename Order >
-inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void geru( Order, fortran_int_t m, fortran_int_t n,
+ std::complex<float> alpha, const std::complex<float>* x,
+ fortran_int_t incx, const std::complex<float>* y, fortran_int_t incy,
+ std::complex<float>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CGERU( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
}
@@ -140,11 +133,10 @@
// * complex<double> value-type.
//
template< typename Order >
-inline void geru( Order, const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void geru( Order, fortran_int_t m, fortran_int_t n,
+ std::complex<double> alpha, const std::complex<double>* x,
+ fortran_int_t incx, const std::complex<double>* y, fortran_int_t incy,
+ std::complex<double>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZGERU( &m, &n, &alpha, x, &incx, y, &incy, a, &lda );
}
@@ -179,7 +171,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -15,6 +15,7 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HBMV_HPP
#include <boost/assert.hpp>
+#include <boost/numeric/bindings/bandwidth.hpp
#include <boost/numeric/bindings/begin.hpp>
#include <boost/numeric/bindings/data_order.hpp>
#include <boost/numeric/bindings/data_side.hpp>
@@ -64,11 +65,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float> beta,
- std::complex<float>* y, const std::ptrdiff_t incy ) {
+inline void hbmv( Order, UpLo, int n, int k, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, const std::complex<float>* x,
+ int incx, std::complex<float> beta, std::complex<float>* y,
+ int incy ) {
cblas_chbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
k, &alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -79,11 +79,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double> beta,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
+inline void hbmv( Order, UpLo, int n, int k, std::complex<double> alpha,
+ const std::complex<double>* a, int lda, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
cblas_zhbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
k, &alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -95,11 +94,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float> beta,
- std::complex<float>* y, const std::ptrdiff_t incy ) {
+inline void hbmv( Order, UpLo, int n, int k, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, const std::complex<float>* x,
+ int incx, std::complex<float> beta, std::complex<float>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasChbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx,
beta, y, incy );
@@ -111,11 +109,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double> beta,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
+inline void hbmv( Order, UpLo, int n, int k, std::complex<double> alpha,
+ const std::complex<double>* a, int lda, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -127,11 +124,11 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float> beta,
- std::complex<float>* y, const std::ptrdiff_t incy ) {
+inline void hbmv( Order, UpLo, fortran_int_t n, fortran_int_t k,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, const std::complex<float>* x, fortran_int_t incx,
+ std::complex<float> beta, std::complex<float>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -143,11 +140,11 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double> beta,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
+inline void hbmv( Order, UpLo, fortran_int_t n, fortran_int_t k,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, const std::complex<double>* x, fortran_int_t incx,
+ std::complex<double> beta, std::complex<double>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -174,9 +171,8 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixA, typename VectorX, typename VectorY >
- 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 ) {
+ 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<
@@ -185,10 +181,11 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixA >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- 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) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ detail::hbmv( order(), uplo(), size_column(a),
+ bandwidth_upper(a), alpha, begin_value(a), stride_major(a),
+ begin_value(x), stride(x), beta, begin_value(y), stride(y) );
}
};
@@ -206,11 +203,11 @@
//
template< typename MatrixA, typename VectorX, typename VectorY >
inline typename hbmv_impl< typename value< MatrixA >::type >::return_type
-hbmv( const std::ptrdiff_t k, const typename value<
- MatrixA >::type alpha, const MatrixA& a, const VectorX& x,
- const typename value< MatrixA >::type beta, VectorY& y ) {
- hbmv_impl< typename value< MatrixA >::type >::invoke( k, alpha, a,
- x, beta, y );
+hbmv( const typename value< MatrixA >::type alpha, const MatrixA& a,
+ const VectorX& x, const typename value< MatrixA >::type beta,
+ VectorY& y ) {
+ hbmv_impl< typename value< MatrixA >::type >::invoke( alpha, a, x,
+ beta, y );
}
//
@@ -219,11 +216,11 @@
//
template< typename MatrixA, typename VectorX, typename VectorY >
inline typename hbmv_impl< typename value< MatrixA >::type >::return_type
-hbmv( const std::ptrdiff_t k, const typename value<
- MatrixA >::type alpha, const MatrixA& a, const VectorX& x,
- const typename value< MatrixA >::type beta, const VectorY& y ) {
- hbmv_impl< typename value< MatrixA >::type >::invoke( k, alpha, a,
- x, beta, y );
+hbmv( const typename value< MatrixA >::type alpha, const MatrixA& a,
+ const VectorX& x, const typename value< MatrixA >::type beta,
+ const VectorY& y ) {
+ hbmv_impl< typename value< MatrixA >::type >::invoke( alpha, a, x,
+ beta, y );
}
} // namespace blas
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,11 +64,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float> beta,
- std::complex<float>* y, const std::ptrdiff_t incy ) {
+inline void hemv( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, const std::complex<float>* x,
+ int incx, std::complex<float> beta, std::complex<float>* y,
+ int incy ) {
cblas_chemv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -79,11 +78,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double> beta,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
+inline void hemv( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* a, int lda, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
cblas_zhemv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, a, lda, x, incx, &beta, y, incy );
}
@@ -95,11 +93,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float> beta,
- std::complex<float>* y, const std::ptrdiff_t incy ) {
+inline void hemv( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, const std::complex<float>* x,
+ int incx, std::complex<float> beta, std::complex<float>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasChemv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta,
y, incy );
@@ -111,11 +108,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double> beta,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
+inline void hemv( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* a, int lda, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -127,11 +123,11 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float> beta,
- std::complex<float>* y, const std::ptrdiff_t incy ) {
+inline void hemv( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
+ const std::complex<float>* a, fortran_int_t lda,
+ const std::complex<float>* x, fortran_int_t incx,
+ std::complex<float> beta, std::complex<float>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHEMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
&beta, y, &incy );
@@ -143,11 +139,11 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hemv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double> beta,
- std::complex<double>* y, const std::ptrdiff_t incy ) {
+inline void hemv( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
+ const std::complex<double>* a, fortran_int_t lda,
+ const std::complex<double>* x, fortran_int_t incx,
+ std::complex<double> beta, std::complex<double>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHEMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
&beta, y, &incy );
@@ -184,7 +180,8 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixA >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,9 +64,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void her( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- std::complex<float>* a, const std::ptrdiff_t lda ) {
+inline void her( Order, UpLo, int n, float alpha,
+ const std::complex<float>* x, int incx, std::complex<float>* a,
+ int lda ) {
cblas_cher( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, a, lda );
}
@@ -77,9 +77,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void her( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* a, const std::ptrdiff_t lda ) {
+inline void her( Order, UpLo, int n, double alpha,
+ const std::complex<double>* x, int incx, std::complex<double>* a,
+ int lda ) {
cblas_zher( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, a, lda );
}
@@ -91,9 +91,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void her( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- std::complex<float>* a, const std::ptrdiff_t lda ) {
+inline void her( Order, UpLo, int n, float alpha,
+ const std::complex<float>* x, int incx, std::complex<float>* a,
+ int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCher( blas_option< UpLo >::value, n, alpha, x, incx, a, lda );
}
@@ -104,9 +104,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void her( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* a, const std::ptrdiff_t lda ) {
+inline void her( Order, UpLo, int n, double alpha,
+ const std::complex<double>* x, int incx, std::complex<double>* a,
+ int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -118,9 +118,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void her( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- std::complex<float>* a, const std::ptrdiff_t lda ) {
+inline void her( Order, UpLo, fortran_int_t n, float alpha,
+ const std::complex<float>* x, fortran_int_t incx,
+ std::complex<float>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHER( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
}
@@ -131,9 +131,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void her( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* a, const std::ptrdiff_t lda ) {
+inline void her( Order, UpLo, fortran_int_t n, double alpha,
+ const std::complex<double>* x, fortran_int_t incx,
+ std::complex<double>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHER( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
}
@@ -166,7 +166,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,11 +64,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void her2( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* a, int lda ) {
cblas_cher2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, x, incx, y, incy, a, lda );
}
@@ -79,11 +77,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void her2( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* a,
+ int lda ) {
cblas_zher2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, x, incx, y, incy, a, lda );
}
@@ -95,11 +92,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void her2( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCher2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a,
lda );
@@ -111,11 +106,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void her2( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* a,
+ int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -127,11 +121,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* a,
- const std::ptrdiff_t lda ) {
+inline void her2( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
+ const std::complex<float>* x, fortran_int_t incx,
+ const std::complex<float>* y, fortran_int_t incy,
+ std::complex<float>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHER2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
a, &lda );
@@ -143,11 +136,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void her2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* a,
- const std::ptrdiff_t lda ) {
+inline void her2( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
+ const std::complex<double>* x, fortran_int_t incx,
+ const std::complex<double>* y, fortran_int_t incy,
+ std::complex<double>* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHER2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
a, &lda );
@@ -184,7 +176,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,11 +64,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* ap,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void hpmv( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* ap, const std::complex<float>* x, int incx,
+ std::complex<float> beta, std::complex<float>* y, int incy ) {
cblas_chpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, ap, x, incx, &beta, y, incy );
}
@@ -79,11 +77,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* ap,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void hpmv( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* ap, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
cblas_zhpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, ap, x, incx, &beta, y, incy );
}
@@ -95,11 +92,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* ap,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void hpmv( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* ap, const std::complex<float>* x, int incx,
+ std::complex<float> beta, std::complex<float>* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasChpmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y,
incy );
@@ -111,11 +106,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* ap,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void hpmv( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* ap, const std::complex<double>* x,
+ int incx, std::complex<double> beta, std::complex<double>* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -127,11 +121,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* ap,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- const std::complex<float> beta, std::complex<float>* y,
- const std::ptrdiff_t incy ) {
+inline void hpmv( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
+ const std::complex<float>* ap, const std::complex<float>* x,
+ fortran_int_t incx, std::complex<float> beta, std::complex<float>* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
y, &incy );
@@ -143,11 +136,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpmv( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* ap,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- const std::complex<double> beta, std::complex<double>* y,
- const std::ptrdiff_t incy ) {
+inline void hpmv( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
+ const std::complex<double>* ap, const std::complex<double>* x,
+ fortran_int_t incx, std::complex<double> beta,
+ std::complex<double>* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
y, &incy );
@@ -184,7 +176,8 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixAP >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,9 +64,8 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- std::complex<float>* ap ) {
+inline void hpr( Order, UpLo, int n, float alpha,
+ const std::complex<float>* x, int incx, std::complex<float>* ap ) {
cblas_chpr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, ap );
}
@@ -77,9 +76,8 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* ap ) {
+inline void hpr( Order, UpLo, int n, double alpha,
+ const std::complex<double>* x, int incx, std::complex<double>* ap ) {
cblas_zhpr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, ap );
}
@@ -91,9 +89,8 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const std::complex<float>* x, const std::ptrdiff_t incx,
- std::complex<float>* ap ) {
+inline void hpr( Order, UpLo, int n, float alpha,
+ const std::complex<float>* x, int incx, std::complex<float>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasChpr( blas_option< UpLo >::value, n, alpha, x, incx, ap );
}
@@ -104,9 +101,8 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const std::complex<double>* x, const std::ptrdiff_t incx,
- std::complex<double>* ap ) {
+inline void hpr( Order, UpLo, int n, double alpha,
+ const std::complex<double>* x, int incx, std::complex<double>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -118,8 +114,8 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const std::complex<float>* x, const std::ptrdiff_t incx,
+inline void hpr( Order, UpLo, fortran_int_t n, float alpha,
+ const std::complex<float>* x, fortran_int_t incx,
std::complex<float>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
@@ -131,8 +127,8 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const std::complex<double>* x, const std::ptrdiff_t incx,
+inline void hpr( Order, UpLo, fortran_int_t n, double alpha,
+ const std::complex<double>* x, fortran_int_t incx,
std::complex<double>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
@@ -166,7 +162,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,10 +64,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* ap ) {
+inline void hpr2( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* ap ) {
cblas_chpr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, x, incx, y, incy, ap );
}
@@ -78,10 +77,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* ap ) {
+inline void hpr2( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* ap ) {
cblas_zhpr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
&alpha, x, incx, y, incy, ap );
}
@@ -93,10 +91,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* ap ) {
+inline void hpr2( Order, UpLo, int n, std::complex<float> alpha,
+ const std::complex<float>* x, int incx, const std::complex<float>* y,
+ int incy, std::complex<float>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasChpr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap );
}
@@ -107,10 +104,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* ap ) {
+inline void hpr2( Order, UpLo, int n, std::complex<double> alpha,
+ const std::complex<double>* x, int incx,
+ const std::complex<double>* y, int incy, std::complex<double>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -122,10 +118,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* x,
- const std::ptrdiff_t incx, const std::complex<float>* y,
- const std::ptrdiff_t incy, std::complex<float>* ap ) {
+inline void hpr2( Order, UpLo, fortran_int_t n, std::complex<float> alpha,
+ const std::complex<float>* x, fortran_int_t incx,
+ const std::complex<float>* y, fortran_int_t incy,
+ std::complex<float>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
ap );
@@ -137,10 +133,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hpr2( Order, UpLo, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* x,
- const std::ptrdiff_t incx, const std::complex<double>* y,
- const std::ptrdiff_t incy, std::complex<double>* ap ) {
+inline void hpr2( Order, UpLo, fortran_int_t n, std::complex<double> alpha,
+ const std::complex<double>* x, fortran_int_t incx,
+ const std::complex<double>* y, fortran_int_t incy,
+ std::complex<double>* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
ap );
@@ -177,7 +173,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -15,6 +15,7 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SBMV_HPP
#include <boost/assert.hpp>
+#include <boost/numeric/bindings/bandwidth.hpp
#include <boost/numeric/bindings/begin.hpp>
#include <boost/numeric/bindings/data_order.hpp>
#include <boost/numeric/bindings/data_side.hpp>
@@ -64,10 +65,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const float alpha, const float* a, const std::ptrdiff_t lda,
- const float* x, const std::ptrdiff_t incx, const float beta, float* y,
- const std::ptrdiff_t incy ) {
+inline void sbmv( Order, UpLo, int n, int k, float alpha, const float* a,
+ int lda, const float* x, int incx, float beta, float* y, int incy ) {
cblas_ssbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
k, alpha, a, lda, x, incx, beta, y, incy );
}
@@ -78,10 +77,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const double alpha, const double* a, const std::ptrdiff_t lda,
- const double* x, const std::ptrdiff_t incx, const double beta,
- double* y, const std::ptrdiff_t incy ) {
+inline void sbmv( Order, UpLo, int n, int k, double alpha, const double* a,
+ int lda, const double* x, int incx, double beta, double* y,
+ int incy ) {
cblas_dsbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
k, alpha, a, lda, x, incx, beta, y, incy );
}
@@ -93,10 +91,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const float alpha, const float* a, const std::ptrdiff_t lda,
- const float* x, const std::ptrdiff_t incx, const float beta, float* y,
- const std::ptrdiff_t incy ) {
+inline void sbmv( Order, UpLo, int n, int k, float alpha, const float* a,
+ int lda, const float* x, int incx, float beta, float* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx,
beta, y, incy );
@@ -108,10 +104,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const double alpha, const double* a, const std::ptrdiff_t lda,
- const double* x, const std::ptrdiff_t incx, const double beta,
- double* y, const std::ptrdiff_t incy ) {
+inline void sbmv( Order, UpLo, int n, int k, double alpha, const double* a,
+ int lda, const double* x, int incx, double beta, double* y,
+ int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -123,10 +118,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const float alpha, const float* a, const std::ptrdiff_t lda,
- const float* x, const std::ptrdiff_t incx, const float beta, float* y,
- const std::ptrdiff_t incy ) {
+inline void sbmv( Order, UpLo, fortran_int_t n, fortran_int_t k, float alpha,
+ const float* a, fortran_int_t lda, const float* x, fortran_int_t incx,
+ float beta, float* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -138,10 +132,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void sbmv( Order, UpLo, const std::ptrdiff_t n, const std::ptrdiff_t k,
- const double alpha, const double* a, const std::ptrdiff_t lda,
- const double* x, const std::ptrdiff_t incx, const double beta,
- double* y, const std::ptrdiff_t incy ) {
+inline void sbmv( Order, UpLo, fortran_int_t n, fortran_int_t k, double alpha,
+ const double* a, fortran_int_t lda, const double* x,
+ fortran_int_t incx, double beta, double* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x,
&incx, &beta, y, &incy );
@@ -168,9 +161,8 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixA, typename VectorX, typename VectorY >
- 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 ) {
+ 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<
@@ -179,10 +171,11 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixA >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
- 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) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ detail::sbmv( order(), uplo(), size_column(a),
+ bandwidth_upper(a), alpha, begin_value(a), stride_major(a),
+ begin_value(x), stride(x), beta, begin_value(y), stride(y) );
}
};
@@ -200,12 +193,12 @@
//
template< typename MatrixA, typename VectorX, typename VectorY >
inline typename sbmv_impl< typename value< MatrixA >::type >::return_type
-sbmv( const std::ptrdiff_t k, const typename remove_imaginary<
- typename value< MatrixA >::type >::type alpha, const MatrixA& a,
- const VectorX& x, const typename remove_imaginary< typename value<
+sbmv( const typename remove_imaginary< typename value<
+ MatrixA >::type >::type alpha, const MatrixA& a, const VectorX& x,
+ const typename remove_imaginary< typename value<
MatrixA >::type >::type beta, VectorY& y ) {
- sbmv_impl< typename value< MatrixA >::type >::invoke( k, alpha, a,
- x, beta, y );
+ sbmv_impl< typename value< MatrixA >::type >::invoke( alpha, a, x,
+ beta, y );
}
//
@@ -214,12 +207,12 @@
//
template< typename MatrixA, typename VectorX, typename VectorY >
inline typename sbmv_impl< typename value< MatrixA >::type >::return_type
-sbmv( const std::ptrdiff_t k, const typename remove_imaginary<
- typename value< MatrixA >::type >::type alpha, const MatrixA& a,
- const VectorX& x, const typename remove_imaginary< typename value<
+sbmv( const typename remove_imaginary< typename value<
+ MatrixA >::type >::type alpha, const MatrixA& a, const VectorX& x,
+ const typename remove_imaginary< typename value<
MatrixA >::type >::type beta, const VectorY& y ) {
- sbmv_impl< typename value< MatrixA >::type >::invoke( k, alpha, a,
- x, beta, y );
+ sbmv_impl< typename value< MatrixA >::type >::invoke( alpha, a, x,
+ beta, y );
}
} // namespace blas
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,9 +64,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* ap, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void spmv( Order, UpLo, int n, float alpha, const float* ap,
+ const float* x, int incx, float beta, float* y, int incy ) {
cblas_sspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, ap, x, incx, beta, y, incy );
}
@@ -77,9 +76,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* ap, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void spmv( Order, UpLo, int n, double alpha, const double* ap,
+ const double* x, int incx, double beta, double* y, int incy ) {
cblas_dspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, ap, x, incx, beta, y, incy );
}
@@ -91,9 +89,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* ap, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void spmv( Order, UpLo, int n, float alpha, const float* ap,
+ const float* x, int incx, float beta, float* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSspmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y,
incy );
@@ -105,9 +102,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* ap, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void spmv( Order, UpLo, int n, double alpha, const double* ap,
+ const double* x, int incx, double beta, double* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -119,9 +115,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* ap, const float* x, const std::ptrdiff_t incx,
- const float beta, float* y, const std::ptrdiff_t incy ) {
+inline void spmv( Order, UpLo, fortran_int_t n, float alpha, const float* ap,
+ const float* x, fortran_int_t incx, float beta, float* y,
+ fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
y, &incy );
@@ -133,9 +129,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spmv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* ap, const double* x, const std::ptrdiff_t incx,
- const double beta, double* y, const std::ptrdiff_t incy ) {
+inline void spmv( Order, UpLo, fortran_int_t n, double alpha,
+ const double* ap, const double* x, fortran_int_t incx, double beta,
+ double* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta,
y, &incy );
@@ -172,7 +168,8 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixAP >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,8 +64,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, float* ap ) {
+inline void spr( Order, UpLo, int n, float alpha, const float* x, int incx,
+ float* ap ) {
cblas_sspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, ap );
}
@@ -76,8 +76,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, double* ap ) {
+inline void spr( Order, UpLo, int n, double alpha, const double* x, int incx,
+ double* ap ) {
cblas_dspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, ap );
}
@@ -89,8 +89,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, float* ap ) {
+inline void spr( Order, UpLo, int n, float alpha, const float* x, int incx,
+ float* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSspr( blas_option< UpLo >::value, n, alpha, x, incx, ap );
}
@@ -101,8 +101,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, double* ap ) {
+inline void spr( Order, UpLo, int n, double alpha, const double* x, int incx,
+ double* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -114,8 +114,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, float* ap ) {
+inline void spr( Order, UpLo, fortran_int_t n, float alpha, const float* x,
+ fortran_int_t incx, float* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
}
@@ -126,8 +126,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, double* ap ) {
+inline void spr( Order, UpLo, fortran_int_t n, double alpha, const double* x,
+ fortran_int_t incx, double* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap );
}
@@ -160,7 +160,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,9 +64,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy, float* ap ) {
+inline void spr2( Order, UpLo, int n, float alpha, const float* x, int incx,
+ const float* y, int incy, float* ap ) {
cblas_sspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, y, incy, ap );
}
@@ -77,9 +76,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy, double* ap ) {
+inline void spr2( Order, UpLo, int n, double alpha, const double* x, int incx,
+ const double* y, int incy, double* ap ) {
cblas_dspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, y, incy, ap );
}
@@ -91,9 +89,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy, float* ap ) {
+inline void spr2( Order, UpLo, int n, float alpha, const float* x, int incx,
+ const float* y, int incy, float* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSspr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap );
}
@@ -104,9 +101,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy, double* ap ) {
+inline void spr2( Order, UpLo, int n, double alpha, const double* x, int incx,
+ const double* y, int incy, double* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -118,9 +114,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy, float* ap ) {
+inline void spr2( Order, UpLo, fortran_int_t n, float alpha, const float* x,
+ fortran_int_t incx, const float* y, fortran_int_t incy, float* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
ap );
@@ -132,9 +127,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void spr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy, double* ap ) {
+inline void spr2( Order, UpLo, fortran_int_t n, double alpha, const double* x,
+ fortran_int_t incx, const double* y, fortran_int_t incy, double* ap ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
ap );
@@ -171,7 +165,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,10 +64,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, const float* x,
- const std::ptrdiff_t incx, const float beta, float* y,
- const std::ptrdiff_t incy ) {
+inline void symv( Order, UpLo, int n, float alpha, const float* a, int lda,
+ const float* x, int incx, float beta, float* y, int incy ) {
cblas_ssymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, a, lda, x, incx, beta, y, incy );
}
@@ -78,10 +76,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, const double* x,
- const std::ptrdiff_t incx, const double beta, double* y,
- const std::ptrdiff_t incy ) {
+inline void symv( Order, UpLo, int n, double alpha, const double* a, int lda,
+ const double* x, int incx, double beta, double* y, int incy ) {
cblas_dsymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, a, lda, x, incx, beta, y, incy );
}
@@ -93,10 +89,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, const float* x,
- const std::ptrdiff_t incx, const float beta, float* y,
- const std::ptrdiff_t incy ) {
+inline void symv( Order, UpLo, int n, float alpha, const float* a, int lda,
+ const float* x, int incx, float beta, float* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsymv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta,
y, incy );
@@ -108,10 +102,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, const double* x,
- const std::ptrdiff_t incx, const double beta, double* y,
- const std::ptrdiff_t incy ) {
+inline void symv( Order, UpLo, int n, double alpha, const double* a, int lda,
+ const double* x, int incx, double beta, double* y, int incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -123,10 +115,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, const float* x,
- const std::ptrdiff_t incx, const float beta, float* y,
- const std::ptrdiff_t incy ) {
+inline void symv( Order, UpLo, fortran_int_t n, float alpha, const float* a,
+ fortran_int_t lda, const float* x, fortran_int_t incx, float beta,
+ float* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
&beta, y, &incy );
@@ -138,10 +129,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void symv( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, const double* x,
- const std::ptrdiff_t incx, const double beta, double* y,
- const std::ptrdiff_t incy ) {
+inline void symv( Order, UpLo, fortran_int_t n, double alpha, const double* a,
+ fortran_int_t lda, const double* x, fortran_int_t incx, double beta,
+ double* y, fortran_int_t incy ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx,
&beta, y, &incy );
@@ -178,7 +168,8 @@
BOOST_STATIC_ASSERT( (is_same< typename remove_const< typename value<
MatrixA >::type >::type, typename remove_const<
typename value< VectorY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorY >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,9 +64,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, float* a,
- const std::ptrdiff_t lda ) {
+inline void syr( Order, UpLo, int n, float alpha, const float* x, int incx,
+ float* a, int lda ) {
cblas_ssyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, a, lda );
}
@@ -77,9 +76,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, double* a,
- const std::ptrdiff_t lda ) {
+inline void syr( Order, UpLo, int n, double alpha, const double* x, int incx,
+ double* a, int lda ) {
cblas_dsyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, a, lda );
}
@@ -91,9 +89,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, float* a,
- const std::ptrdiff_t lda ) {
+inline void syr( Order, UpLo, int n, float alpha, const float* x, int incx,
+ float* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda );
}
@@ -104,9 +101,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, double* a,
- const std::ptrdiff_t lda ) {
+inline void syr( Order, UpLo, int n, double alpha, const double* x, int incx,
+ double* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda );
}
@@ -118,9 +114,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, float* a,
- const std::ptrdiff_t lda ) {
+inline void syr( Order, UpLo, fortran_int_t n, float alpha, const float* x,
+ fortran_int_t incx, float* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
}
@@ -131,9 +126,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void syr( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, double* a,
- const std::ptrdiff_t lda ) {
+inline void syr( Order, UpLo, fortran_int_t n, double alpha, const double* x,
+ fortran_int_t incx, double* a, fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda );
}
@@ -166,7 +160,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,9 +64,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy, float* a, const std::ptrdiff_t lda ) {
+inline void syr2( Order, UpLo, int n, float alpha, const float* x, int incx,
+ const float* y, int incy, float* a, int lda ) {
cblas_ssyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, y, incy, a, lda );
}
@@ -77,9 +76,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy, double* a, const std::ptrdiff_t lda ) {
+inline void syr2( Order, UpLo, int n, double alpha, const double* x, int incx,
+ const double* y, int incy, double* a, int lda ) {
cblas_dsyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n,
alpha, x, incx, y, incy, a, lda );
}
@@ -91,9 +89,8 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy, float* a, const std::ptrdiff_t lda ) {
+inline void syr2( Order, UpLo, int n, float alpha, const float* x, int incx,
+ const float* y, int incy, float* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsyr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a,
lda );
@@ -105,9 +102,8 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy, double* a, const std::ptrdiff_t lda ) {
+inline void syr2( Order, UpLo, int n, double alpha, const double* x, int incx,
+ const double* y, int incy, double* a, int lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -119,9 +115,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, const std::ptrdiff_t n, const float alpha,
- const float* x, const std::ptrdiff_t incx, const float* y,
- const std::ptrdiff_t incy, float* a, const std::ptrdiff_t lda ) {
+inline void syr2( Order, UpLo, fortran_int_t n, float alpha, const float* x,
+ fortran_int_t incx, const float* y, fortran_int_t incy, float* a,
+ fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
a, &lda );
@@ -133,9 +129,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void syr2( Order, UpLo, const std::ptrdiff_t n, const double alpha,
- const double* x, const std::ptrdiff_t incx, const double* y,
- const std::ptrdiff_t incy, double* a, const std::ptrdiff_t lda ) {
+inline void syr2( Order, UpLo, fortran_int_t n, double alpha, const double* x,
+ fortran_int_t incx, const double* y, fortran_int_t incy, double* a,
+ fortran_int_t lda ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy,
a, &lda );
@@ -172,7 +168,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -15,6 +15,7 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TBMV_HPP
#include <boost/assert.hpp>
+#include <boost/numeric/bindings/bandwidth.hpp
#include <boost/numeric/bindings/begin.hpp>
#include <boost/numeric/bindings/blas/detail/default_order.hpp>
#include <boost/numeric/bindings/data_side.hpp>
@@ -66,9 +67,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float* a, const std::ptrdiff_t lda,
- float* x, const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
+ int lda, float* x, int incx ) {
cblas_stbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -80,9 +80,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double* a, const std::ptrdiff_t lda,
- double* x, const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
+ int lda, double* x, int incx ) {
cblas_dtbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -94,10 +93,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
cblas_ctbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -109,10 +107,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
cblas_ztbmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -125,9 +122,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float* a, const std::ptrdiff_t lda,
- float* x, const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
+ int lda, float* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStbmv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -139,9 +135,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double* a, const std::ptrdiff_t lda,
- double* x, const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
+ int lda, double* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -152,10 +147,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtbmv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -167,10 +161,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -182,9 +175,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float* a, const std::ptrdiff_t lda,
- float* x, const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const float* a, fortran_int_t lda, float* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -196,9 +188,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double* a, const std::ptrdiff_t lda,
- double* x, const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const double* a, fortran_int_t lda, double* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -210,10 +201,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const std::complex<float>* a, fortran_int_t lda,
+ std::complex<float>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -225,10 +215,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tbmv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const std::complex<double>* a, fortran_int_t lda,
+ std::complex<double>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -264,7 +253,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -15,6 +15,7 @@
#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TBSV_HPP
#include <boost/assert.hpp>
+#include <boost/numeric/bindings/bandwidth.hpp
#include <boost/numeric/bindings/begin.hpp>
#include <boost/numeric/bindings/blas/detail/default_order.hpp>
#include <boost/numeric/bindings/data_side.hpp>
@@ -66,9 +67,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float* a, const std::ptrdiff_t lda,
- float* x, const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
+ int lda, float* x, int incx ) {
cblas_stbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -80,9 +80,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double* a, const std::ptrdiff_t lda,
- double* x, const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
+ int lda, double* x, int incx ) {
cblas_dtbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -94,10 +93,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
cblas_ctbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -109,10 +107,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
cblas_ztbsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, k,
a, lda, x, incx );
@@ -125,9 +122,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float* a, const std::ptrdiff_t lda,
- float* x, const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const float* a,
+ int lda, float* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStbsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -139,9 +135,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double* a, const std::ptrdiff_t lda,
- double* x, const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k, const double* a,
+ int lda, double* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -152,10 +147,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtbsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, k, a, lda, x, incx );
@@ -167,10 +161,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, int n, int k,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -182,9 +175,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float* a, const std::ptrdiff_t lda,
- float* x, const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const float* a, fortran_int_t lda, float* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -196,9 +188,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tbsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double* a, const std::ptrdiff_t lda,
- double* x, const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const double* a, fortran_int_t lda, double* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -210,10 +201,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const std::complex<float>* a, fortran_int_t lda,
+ std::complex<float>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -225,10 +215,9 @@
// * 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,
- const std::ptrdiff_t k, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tbsv( Order, UpLo, Trans, Diag, fortran_int_t n, fortran_int_t k,
+ const std::complex<double>* a, fortran_int_t lda,
+ std::complex<double>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, &k, a, &lda, x, &incx );
@@ -264,7 +253,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -66,8 +66,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* ap, float* x, const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
+ int incx ) {
cblas_stpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -79,8 +79,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* ap, double* x, const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n, const double* ap,
+ double* x, int incx ) {
cblas_dtpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -92,9 +92,8 @@
// * 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,
- const std::complex<float>* ap, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* ap, std::complex<float>* x, int incx ) {
cblas_ctpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -106,9 +105,8 @@
// * 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,
- const std::complex<double>* ap, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* ap, std::complex<double>* x, int incx ) {
cblas_ztpmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -121,8 +119,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* ap, float* x, const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStpmv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, ap, x, incx );
@@ -134,8 +132,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* ap, double* x, const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n, const double* ap,
+ double* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -146,9 +144,8 @@
// * 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,
- const std::complex<float>* ap, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* ap, std::complex<float>* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtpmv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, ap, x, incx );
@@ -160,9 +157,8 @@
// * 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,
- const std::complex<double>* ap, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* ap, std::complex<double>* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -174,8 +170,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* ap, float* x, const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* ap,
+ float* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -187,8 +183,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* ap, double* x, const std::ptrdiff_t incx ) {
+inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* ap,
+ double* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -200,9 +196,9 @@
// * 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,
+inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n,
const std::complex<float>* ap, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+ fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -214,9 +210,9 @@
// * 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,
+inline void tpmv( Order, UpLo, Trans, Diag, fortran_int_t n,
const std::complex<double>* ap, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+ fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -251,7 +247,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -66,8 +66,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* ap, float* x, const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
+ int incx ) {
cblas_stpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -79,8 +79,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* ap, double* x, const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n, const double* ap,
+ double* x, int incx ) {
cblas_dtpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -92,9 +92,8 @@
// * 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,
- const std::complex<float>* ap, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* ap, std::complex<float>* x, int incx ) {
cblas_ctpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -106,9 +105,8 @@
// * 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,
- const std::complex<double>* ap, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* ap, std::complex<double>* x, int incx ) {
cblas_ztpsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap,
x, incx );
@@ -121,8 +119,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* ap, float* x, const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n, const float* ap, float* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStpsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, ap, x, incx );
@@ -134,8 +132,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* ap, double* x, const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n, const double* ap,
+ double* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -146,9 +144,8 @@
// * 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,
- const std::complex<float>* ap, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* ap, std::complex<float>* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtpsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, ap, x, incx );
@@ -160,9 +157,8 @@
// * 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,
- const std::complex<double>* ap, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* ap, std::complex<double>* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -174,8 +170,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* ap, float* x, const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* ap,
+ float* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -187,8 +183,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void tpsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* ap, double* x, const std::ptrdiff_t incx ) {
+inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* ap,
+ double* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -200,9 +196,9 @@
// * 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,
+inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n,
const std::complex<float>* ap, std::complex<float>* x,
- const std::ptrdiff_t incx ) {
+ fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -214,9 +210,9 @@
// * 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,
+inline void tpsv( Order, UpLo, Trans, Diag, fortran_int_t n,
const std::complex<double>* ap, std::complex<double>* x,
- const std::ptrdiff_t incx ) {
+ fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, ap, x, &incx );
@@ -251,7 +247,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size_minor(ap) == 1 || stride_minor(ap) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -66,9 +66,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* a, const std::ptrdiff_t lda, float* x,
- const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
+ float* x, int incx ) {
cblas_strmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -80,9 +79,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* a, const std::ptrdiff_t lda, double* x,
- const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
+ double* x, int incx ) {
cblas_dtrmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -94,9 +92,9 @@
// * 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,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
cblas_ctrmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -108,9 +106,9 @@
// * 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,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
cblas_ztrmv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -123,9 +121,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* a, const std::ptrdiff_t lda, float* x,
- const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
+ float* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStrmv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, a, lda, x, incx );
@@ -137,9 +134,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* a, const std::ptrdiff_t lda, double* x,
- const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
+ double* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -150,9 +146,9 @@
// * 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,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -163,9 +159,9 @@
// * 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,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -177,9 +173,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* a, const std::ptrdiff_t lda, float* x,
- const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* a,
+ fortran_int_t lda, float* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -191,9 +186,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trmv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* a, const std::ptrdiff_t lda, double* x,
- const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* a,
+ fortran_int_t lda, double* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -205,9 +199,9 @@
// * 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,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n,
+ const std::complex<float>* a, fortran_int_t lda,
+ std::complex<float>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -219,9 +213,9 @@
// * 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,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void trmv( Order, UpLo, Trans, Diag, fortran_int_t n,
+ const std::complex<double>* a, fortran_int_t lda,
+ std::complex<double>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -256,7 +250,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -66,9 +66,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* a, const std::ptrdiff_t lda, float* x,
- const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
+ float* x, int incx ) {
cblas_strsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -80,9 +79,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* a, const std::ptrdiff_t lda, double* x,
- const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
+ double* x, int incx ) {
cblas_dtrsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -94,9 +92,9 @@
// * 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,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
cblas_ctrsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -108,9 +106,9 @@
// * 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,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
cblas_ztrsv( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, cblas_option< Diag >::value, n, a,
lda, x, incx );
@@ -123,9 +121,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* a, const std::ptrdiff_t lda, float* x,
- const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n, const float* a, int lda,
+ float* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStrsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, a, lda, x, incx );
@@ -137,9 +134,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* a, const std::ptrdiff_t lda, double* x,
- const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n, const double* a, int lda,
+ double* x, int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDtrsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, a, lda, x, incx );
@@ -151,9 +147,9 @@
// * 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,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<float>* a, int lda, std::complex<float>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtrsv( blas_option< UpLo >::value, blas_option< Trans >::value,
blas_option< Diag >::value, n, a, lda, x, incx );
@@ -165,9 +161,9 @@
// * 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,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, int n,
+ const std::complex<double>* a, int lda, std::complex<double>* x,
+ int incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -179,9 +175,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const float* a, const std::ptrdiff_t lda, float* x,
- const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n, const float* a,
+ fortran_int_t lda, float* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -193,9 +188,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans, typename Diag >
-inline void trsv( Order, UpLo, Trans, Diag, const std::ptrdiff_t n,
- const double* a, const std::ptrdiff_t lda, double* x,
- const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n, const double* a,
+ fortran_int_t lda, double* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -207,9 +201,9 @@
// * 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,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- std::complex<float>* x, const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n,
+ const std::complex<float>* a, fortran_int_t lda,
+ std::complex<float>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -221,9 +215,9 @@
// * 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,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- std::complex<double>* x, const std::ptrdiff_t incx ) {
+inline void trsv( Order, UpLo, Trans, Diag, fortran_int_t n,
+ const std::complex<double>* a, fortran_int_t lda,
+ std::complex<double>* x, fortran_int_t incx ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&blas_option< Diag >::value, &n, a, &lda, x, &incx );
@@ -258,7 +252,8 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorX >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,11 +64,9 @@
// * float value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k, const float alpha,
- const float* a, const std::ptrdiff_t lda, const float* b,
- const std::ptrdiff_t ldb, const float beta, float* c,
- const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k, float alpha,
+ const float* a, int lda, const float* b, int ldb, float beta,
+ float* c, int ldc ) {
cblas_sgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
cblas_option< TransB >::value, m, n, k, alpha, a, lda, b, ldb,
beta, c, ldc );
@@ -80,11 +78,9 @@
// * double value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k, const double alpha,
- const double* a, const std::ptrdiff_t lda, const double* b,
- const std::ptrdiff_t ldb, const double beta, double* c,
- const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k, double alpha,
+ const double* a, int lda, const double* b, int ldb, double beta,
+ double* c, int ldc ) {
cblas_dgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
cblas_option< TransB >::value, m, n, k, alpha, a, lda, b, ldb,
beta, c, ldc );
@@ -96,12 +92,10 @@
// * complex<float> value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* b,
- const std::ptrdiff_t ldb, const std::complex<float> beta,
- std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
cblas_cgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
cblas_option< TransB >::value, m, n, k, &alpha, a, lda, b, ldb,
&beta, c, ldc );
@@ -113,12 +107,10 @@
// * complex<double> value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* b,
- const std::ptrdiff_t ldb, const std::complex<double> beta,
- std::complex<double>* c, const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
cblas_zgemm( cblas_option< Order >::value, cblas_option< TransA >::value,
cblas_option< TransB >::value, m, n, k, &alpha, a, lda, b, ldb,
&beta, c, ldc );
@@ -131,11 +123,9 @@
// * float value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k, const float alpha,
- const float* a, const std::ptrdiff_t lda, const float* b,
- const std::ptrdiff_t ldb, const float beta, float* c,
- const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k, float alpha,
+ const float* a, int lda, const float* b, int ldb, float beta,
+ float* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSgemm( blas_option< TransA >::value, blas_option< TransB >::value,
m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -147,11 +137,9 @@
// * double value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k, const double alpha,
- const double* a, const std::ptrdiff_t lda, const double* b,
- const std::ptrdiff_t ldb, const double beta, double* c,
- const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k, double alpha,
+ const double* a, int lda, const double* b, int ldb, double beta,
+ double* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDgemm( blas_option< TransA >::value, blas_option< TransB >::value,
m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -163,12 +151,10 @@
// * complex<float> value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* b,
- const std::ptrdiff_t ldb, const std::complex<float> beta,
- std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCgemm( blas_option< TransA >::value, blas_option< TransB >::value,
m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -180,12 +166,10 @@
// * complex<double> value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* b,
- const std::ptrdiff_t ldb, const std::complex<double> beta,
- std::complex<double>* c, const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, int m, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasZgemm( blas_option< TransA >::value, blas_option< TransB >::value,
m, n, k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -198,11 +182,10 @@
// * float value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k, const float alpha,
- const float* a, const std::ptrdiff_t lda, const float* b,
- const std::ptrdiff_t ldb, const float beta, float* c,
- const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
+ fortran_int_t k, float alpha, const float* a, fortran_int_t lda,
+ const float* b, fortran_int_t ldb, float beta, float* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
&m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -214,11 +197,10 @@
// * double value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k, const double alpha,
- const double* a, const std::ptrdiff_t lda, const double* b,
- const std::ptrdiff_t ldb, const double beta, double* c,
- const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
+ fortran_int_t k, double alpha, const double* a, fortran_int_t lda,
+ const double* b, fortran_int_t ldb, double beta, double* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
&m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -230,12 +212,11 @@
// * complex<float> value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, const std::complex<float>* b,
- const std::ptrdiff_t ldb, const std::complex<float> beta,
- std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
+ fortran_int_t k, std::complex<float> alpha,
+ const std::complex<float>* a, fortran_int_t lda,
+ const std::complex<float>* b, fortran_int_t ldb,
+ std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
&m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -247,12 +228,12 @@
// * complex<double> value-type.
//
template< typename Order, typename TransA, typename TransB >
-inline void gemm( Order, TransA, TransB, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::ptrdiff_t k,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, const std::complex<double>* b,
- const std::ptrdiff_t ldb, const std::complex<double> beta,
- std::complex<double>* c, const std::ptrdiff_t ldc ) {
+inline void gemm( Order, TransA, TransB, fortran_int_t m, fortran_int_t n,
+ fortran_int_t k, std::complex<double> alpha,
+ const std::complex<double>* a, fortran_int_t lda,
+ const std::complex<double>* b, fortran_int_t ldb,
+ std::complex<double> beta, std::complex<double>* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value,
&m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -290,7 +271,10 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,12 +64,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void hemm( Order, char side, UpLo, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
cblas_chemm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
c, ldc );
@@ -81,12 +79,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void hemm( Order, char side, UpLo, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
cblas_zhemm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
c, ldc );
@@ -99,12 +95,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void hemm( Order, char side, UpLo, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasChemm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
ldb, beta, c, ldc );
@@ -116,12 +110,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void hemm( Order, char side, UpLo, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -133,12 +125,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void hemm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
+ std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHEMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
b, &ldb, &beta, c, &ldc );
@@ -150,12 +140,11 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void hemm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void hemm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
+ std::complex<double> beta, std::complex<double>* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHEMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
b, &ldb, &beta, c, &ldc );
@@ -193,8 +182,11 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -65,11 +65,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const float beta, std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void her2k( Order, UpLo, Trans, int n, int k,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, float beta,
+ std::complex<float>* c, int ldc ) {
cblas_cher2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, beta,
c, ldc );
@@ -81,12 +80,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const double beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void her2k( Order, UpLo, Trans, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, double beta,
+ std::complex<double>* c, int ldc ) {
cblas_zher2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, beta,
c, ldc );
@@ -99,11 +96,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const float beta, std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void her2k( Order, UpLo, Trans, int n, int k,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, float beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCher2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -115,12 +111,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const double beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void her2k( Order, UpLo, Trans, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, double beta,
+ std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -132,11 +126,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const float beta, std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void her2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
+ float beta, std::complex<float>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHER2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -148,12 +141,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void her2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const double beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void her2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
+ double beta, std::complex<double>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHER2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -191,7 +182,10 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -65,10 +65,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const float beta, std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void herk( Order, UpLo, Trans, int n, int k, float alpha,
+ const std::complex<float>* a, int lda, float beta,
+ std::complex<float>* c, int ldc ) {
cblas_cherk( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
}
@@ -79,11 +78,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const double beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void herk( Order, UpLo, Trans, int n, int k, double alpha,
+ const std::complex<double>* a, int lda, double beta,
+ std::complex<double>* c, int ldc ) {
cblas_zherk( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
}
@@ -95,10 +92,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const float beta, std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void herk( Order, UpLo, Trans, int n, int k, float alpha,
+ const std::complex<float>* a, int lda, float beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCherk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, beta, c, ldc );
@@ -110,11 +106,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const double beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void herk( Order, UpLo, Trans, int n, int k, double alpha,
+ const std::complex<double>* a, int lda, double beta,
+ std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -126,10 +120,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const float beta, std::complex<float>* c, const std::ptrdiff_t ldc ) {
+inline void herk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ float alpha, const std::complex<float>* a, fortran_int_t lda,
+ float beta, std::complex<float>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CHERK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
&k, &alpha, a, &lda, &beta, c, &ldc );
@@ -141,11 +134,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void herk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const double beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void herk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ double alpha, const std::complex<double>* a, fortran_int_t lda,
+ double beta, std::complex<double>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZHERK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
&k, &alpha, a, &lda, &beta, c, &ldc );
@@ -180,7 +171,9 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -64,10 +64,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* b, const std::ptrdiff_t ldb,
- const float beta, float* c, const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n, float alpha,
+ const float* a, int lda, const float* b, int ldb, float beta,
+ float* c, int ldc ) {
cblas_ssymm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c,
ldc );
@@ -79,10 +78,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* b, const std::ptrdiff_t ldb,
- const double beta, double* c, const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n, double alpha,
+ const double* a, int lda, const double* b, int ldb, double beta,
+ double* c, int ldc ) {
cblas_dsymm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c,
ldc );
@@ -94,12 +92,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
cblas_csymm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
c, ldc );
@@ -111,12 +107,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
cblas_zsymm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta,
c, ldc );
@@ -129,10 +123,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* b, const std::ptrdiff_t ldb,
- const float beta, float* c, const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n, float alpha,
+ const float* a, int lda, const float* b, int ldb, float beta,
+ float* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsymm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
ldb, beta, c, ldc );
@@ -144,10 +137,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* b, const std::ptrdiff_t ldb,
- const double beta, double* c, const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n, double alpha,
+ const double* a, int lda, const double* b, int ldb, double beta,
+ double* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDsymm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
ldb, beta, c, ldc );
@@ -159,12 +151,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCsymm( side, blas_option< UpLo >::value, m, n, alpha, a, lda, b,
ldb, beta, c, ldc );
@@ -176,12 +166,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -193,10 +181,9 @@
// * float value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* b, const std::ptrdiff_t ldb,
- const float beta, float* c, const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
+ float alpha, const float* a, fortran_int_t lda, const float* b,
+ fortran_int_t ldb, float beta, float* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
b, &ldb, &beta, c, &ldc );
@@ -208,10 +195,9 @@
// * double value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* b, const std::ptrdiff_t ldb,
- const double beta, double* c, const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
+ double alpha, const double* a, fortran_int_t lda, const double* b,
+ fortran_int_t ldb, double beta, double* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
b, &ldb, &beta, c, &ldc );
@@ -223,12 +209,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
+ std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
b, &ldb, &beta, c, &ldc );
@@ -240,12 +224,11 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo >
-inline void symm( Order, const char side, UpLo, const std::ptrdiff_t m,
- const std::ptrdiff_t n, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void symm( Order, char side, UpLo, fortran_int_t m, fortran_int_t n,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
+ std::complex<double> beta, std::complex<double>* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZSYMM( &side, &blas_option< UpLo >::value, &m, &n, &alpha, a, &lda,
b, &ldb, &beta, c, &ldc );
@@ -283,8 +266,11 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -65,10 +65,9 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* b, const std::ptrdiff_t ldb,
- const float beta, float* c, const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k, float alpha,
+ const float* a, int lda, const float* b, int ldb, float beta,
+ float* c, int ldc ) {
cblas_ssyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta,
c, ldc );
@@ -80,10 +79,9 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* b, const std::ptrdiff_t ldb,
- const double beta, double* c, const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k, double alpha,
+ const double* a, int lda, const double* b, int ldb, double beta,
+ double* c, int ldc ) {
cblas_dsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta,
c, ldc );
@@ -95,12 +93,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
cblas_csyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, &beta,
c, ldc );
@@ -112,12 +108,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
cblas_zsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, &beta,
c, ldc );
@@ -130,10 +124,9 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* b, const std::ptrdiff_t ldb,
- const float beta, float* c, const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k, float alpha,
+ const float* a, int lda, const float* b, int ldb, float beta,
+ float* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -145,10 +138,9 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* b, const std::ptrdiff_t ldb,
- const double beta, double* c, const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k, double alpha,
+ const double* a, int lda, const double* b, int ldb, double beta,
+ double* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -160,12 +152,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ const std::complex<float>* b, int ldb, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, b, ldb, beta, c, ldc );
@@ -177,12 +167,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ const std::complex<double>* b, int ldb, std::complex<double> beta,
+ std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -194,10 +182,9 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float* b, const std::ptrdiff_t ldb,
- const float beta, float* c, const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ float alpha, const float* a, fortran_int_t lda, const float* b,
+ fortran_int_t ldb, float beta, float* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -209,10 +196,9 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double* b, const std::ptrdiff_t ldb,
- const double beta, double* c, const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ double alpha, const double* a, fortran_int_t lda, const double* b,
+ fortran_int_t ldb, double beta, double* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -224,12 +210,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float>* b, const std::ptrdiff_t ldb,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, const std::complex<float>* b, fortran_int_t ldb,
+ std::complex<float> beta, std::complex<float>* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -241,12 +225,11 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syr2k( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double>* b, const std::ptrdiff_t ldb,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void syr2k( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, const std::complex<double>* b, fortran_int_t ldb,
+ std::complex<double> beta, std::complex<double>* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value,
&n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc );
@@ -284,7 +267,10 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -65,10 +65,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float beta, float* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k, float alpha,
+ const float* a, int lda, float beta, float* c, int ldc ) {
cblas_ssyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
}
@@ -79,10 +77,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double beta, double* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k, double alpha,
+ const double* a, int lda, double beta, double* c, int ldc ) {
cblas_dsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc );
}
@@ -93,11 +89,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
cblas_csyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, &alpha, a, lda, &beta, c,
ldc );
@@ -109,11 +103,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ std::complex<double> beta, std::complex<double>* c, int ldc ) {
cblas_zsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value,
cblas_option< Trans >::value, n, k, &alpha, a, lda, &beta, c,
ldc );
@@ -126,10 +118,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float beta, float* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k, float alpha,
+ const float* a, int lda, float beta, float* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasSsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, beta, c, ldc );
@@ -141,10 +131,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double beta, double* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k, double alpha,
+ const double* a, int lda, double beta, double* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, beta, c, ldc );
@@ -156,11 +144,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k, std::complex<float> alpha,
+ const std::complex<float>* a, int lda, std::complex<float> beta,
+ std::complex<float>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, beta, c, ldc );
@@ -172,11 +158,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, int n, int k,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ std::complex<double> beta, std::complex<double>* c, int ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasZsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n,
k, alpha, a, lda, beta, c, ldc );
@@ -189,10 +173,9 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const float alpha, const float* a,
- const std::ptrdiff_t lda, const float beta, float* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ float alpha, const float* a, fortran_int_t lda, float beta, float* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_SSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
&k, &alpha, a, &lda, &beta, c, &ldc );
@@ -204,10 +187,9 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const double alpha, const double* a,
- const std::ptrdiff_t lda, const double beta, double* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ double alpha, const double* a, fortran_int_t lda, double beta,
+ double* c, fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
&k, &alpha, a, &lda, &beta, c, &ldc );
@@ -219,11 +201,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<float> alpha,
- const std::complex<float>* a, const std::ptrdiff_t lda,
- const std::complex<float> beta, std::complex<float>* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ std::complex<float> alpha, const std::complex<float>* a,
+ fortran_int_t lda, std::complex<float> beta, std::complex<float>* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
&k, &alpha, a, &lda, &beta, c, &ldc );
@@ -235,11 +216,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename Trans >
-inline void syrk( Order, UpLo, Trans, const std::ptrdiff_t n,
- const std::ptrdiff_t k, const std::complex<double> alpha,
- const std::complex<double>* a, const std::ptrdiff_t lda,
- const std::complex<double> beta, std::complex<double>* c,
- const std::ptrdiff_t ldc ) {
+inline void syrk( Order, UpLo, Trans, fortran_int_t n, fortran_int_t k,
+ std::complex<double> alpha, const std::complex<double>* a,
+ fortran_int_t lda, std::complex<double> beta, std::complex<double>* c,
+ fortran_int_t ldc ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n,
&k, &alpha, a, &lda, &beta, c, &ldc );
@@ -274,7 +254,9 @@
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 ) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixC >::value) );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(c) == 1 || stride_minor(c) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -66,10 +66,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, float* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ float alpha, const float* a, int lda, float* b, int ldb ) {
cblas_strmm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -81,10 +79,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, double* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ double alpha, const double* a, int lda, double* b, int ldb ) {
cblas_dtrmm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -96,11 +92,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ std::complex<float>* b, int ldb ) {
cblas_ctrmm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -112,11 +106,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ std::complex<double>* b, int ldb ) {
cblas_ztrmm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -129,10 +121,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, float* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ float alpha, const float* a, int lda, float* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStrmm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -145,10 +135,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, double* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ double alpha, const double* a, int lda, double* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDtrmm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -161,11 +149,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ std::complex<float>* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtrmm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -178,11 +164,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ std::complex<double>* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
// NOT FOUND();
}
@@ -194,10 +178,9 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, float* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, float alpha, const float* a, fortran_int_t lda,
+ float* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STRMM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -210,10 +193,9 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, double* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, double alpha, const double* a, fortran_int_t lda,
+ double* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTRMM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -226,11 +208,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, std::complex<float> alpha,
+ const std::complex<float>* a, fortran_int_t lda,
+ std::complex<float>* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTRMM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -243,11 +224,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trmm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* b,
- const std::ptrdiff_t ldb ) {
+inline void trmm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, std::complex<double> alpha,
+ const std::complex<double>* a, fortran_int_t lda,
+ std::complex<double>* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTRMM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -284,8 +264,10 @@
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_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
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 2010-01-05 12:00:28 EST (Tue, 05 Jan 2010)
@@ -66,10 +66,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, float* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ float alpha, const float* a, int lda, float* b, int ldb ) {
cblas_strsm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -81,10 +79,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, double* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ double alpha, const double* a, int lda, double* b, int ldb ) {
cblas_dtrsm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb );
@@ -96,11 +92,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ std::complex<float>* b, int ldb ) {
cblas_ctrsm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -112,11 +106,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ std::complex<double>* b, int ldb ) {
cblas_ztrsm( cblas_option< Order >::value, cblas_option< Side >::value,
cblas_option< UpLo >::value, cblas_option< TransA >::value,
cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb );
@@ -129,10 +121,8 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, float* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ float alpha, const float* a, int lda, float* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasStrsm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -145,10 +135,8 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, double* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ double alpha, const double* a, int lda, double* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasDtrsm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -161,11 +149,9 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<float> alpha, const std::complex<float>* a, int lda,
+ std::complex<float>* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasCtrsm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -178,11 +164,9 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, int m, int n,
+ std::complex<double> alpha, const std::complex<double>* a, int lda,
+ std::complex<double>* b, int ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
cublasZtrsm( side, blas_option< UpLo >::value, blas_option<
TransA >::value, blas_option< Diag >::value, m, n, alpha, a, lda,
@@ -196,10 +180,9 @@
// * float value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const float alpha,
- const float* a, const std::ptrdiff_t lda, float* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, float alpha, const float* a, fortran_int_t lda,
+ float* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_STRSM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -212,10 +195,9 @@
// * double value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n, const double alpha,
- const double* a, const std::ptrdiff_t lda, double* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, double alpha, const double* a, fortran_int_t lda,
+ double* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_DTRSM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -228,11 +210,10 @@
// * complex<float> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<float> alpha, const std::complex<float>* a,
- const std::ptrdiff_t lda, std::complex<float>* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, std::complex<float> alpha,
+ const std::complex<float>* a, fortran_int_t lda,
+ std::complex<float>* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_CTRSM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -245,11 +226,10 @@
// * complex<double> value-type.
//
template< typename Order, typename UpLo, typename TransA, typename Diag >
-inline void trsm( Order, const char side, UpLo, TransA, Diag,
- const std::ptrdiff_t m, const std::ptrdiff_t n,
- const std::complex<double> alpha, const std::complex<double>* a,
- const std::ptrdiff_t lda, std::complex<double>* b,
- const std::ptrdiff_t ldb ) {
+inline void trsm( Order, char side, UpLo, TransA, Diag, fortran_int_t m,
+ fortran_int_t n, std::complex<double> alpha,
+ const std::complex<double>* a, fortran_int_t lda,
+ std::complex<double>* b, fortran_int_t ldb ) {
BOOST_STATIC_ASSERT( (is_column_major<Order>::value) );
BLAS_ZTRSM( &side, &blas_option< UpLo >::value, &blas_option<
TransA >::value, &blas_option< Diag >::value, &m, &n, &alpha, a,
@@ -286,8 +266,10 @@
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_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
BOOST_ASSERT( side == 'L' || side == 'R' );
+ BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
+ BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
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) );
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