|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r50303 - in sandbox/boost/numeric/bindings: amos blas lapack traits traits/detail
From: thomas.klimpel_at_[hidden]
Date: 2008-12-17 11:23:11
Author: klimpel
Date: 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
New Revision: 50303
URL: http://svn.boost.org/trac/boost/changeset/50303
Log:
64-bit support, first version
Text files modified:
sandbox/boost/numeric/bindings/amos/amos.h | 18
sandbox/boost/numeric/bindings/amos/amos.hpp | 24
sandbox/boost/numeric/bindings/amos/amos_overloads.hpp | 14
sandbox/boost/numeric/bindings/blas/blas.h | 142 ++--
sandbox/boost/numeric/bindings/blas/blas1.hpp | 42
sandbox/boost/numeric/bindings/blas/blas1_overloads.hpp | 60
sandbox/boost/numeric/bindings/blas/blas2.hpp | 30
sandbox/boost/numeric/bindings/blas/blas2_overloads.hpp | 16
sandbox/boost/numeric/bindings/blas/blas3.hpp | 32
sandbox/boost/numeric/bindings/blas/blas3_overloads.hpp | 80 +-
sandbox/boost/numeric/bindings/lapack/gbsv.hpp | 62
sandbox/boost/numeric/bindings/lapack/gees.hpp | 52
sandbox/boost/numeric/bindings/lapack/geev.hpp | 72 +-
sandbox/boost/numeric/bindings/lapack/gels.hpp | 68 +-
sandbox/boost/numeric/bindings/lapack/gelsd.hpp | 216 +++---
sandbox/boost/numeric/bindings/lapack/gelss.hpp | 150 ++--
sandbox/boost/numeric/bindings/lapack/geqrf.hpp | 44
sandbox/boost/numeric/bindings/lapack/gesdd.hpp | 190 ++--
sandbox/boost/numeric/bindings/lapack/gesv.hpp | 132 ++--
sandbox/boost/numeric/bindings/lapack/gesvd.hpp | 136 ++--
sandbox/boost/numeric/bindings/lapack/hbev.hpp | 76 +-
sandbox/boost/numeric/bindings/lapack/hbevx.hpp | 122 +-
sandbox/boost/numeric/bindings/lapack/heev.hpp | 32
sandbox/boost/numeric/bindings/lapack/heevd.hpp | 80 +-
sandbox/boost/numeric/bindings/lapack/heevx.hpp | 124 +-
sandbox/boost/numeric/bindings/lapack/hegv.hpp | 80 +-
sandbox/boost/numeric/bindings/lapack/hesv.hpp | 124 +-
sandbox/boost/numeric/bindings/lapack/hpsv.hpp | 50
sandbox/boost/numeric/bindings/lapack/hseqr.hpp | 56
sandbox/boost/numeric/bindings/lapack/ilaenv.hpp | 6
sandbox/boost/numeric/bindings/lapack/lapack.h | 1302 ++++++++++++++++++++--------------------
sandbox/boost/numeric/bindings/lapack/orgqr.hpp | 46
sandbox/boost/numeric/bindings/lapack/ormqr.hpp | 50
sandbox/boost/numeric/bindings/lapack/posv.hpp | 76 +-
sandbox/boost/numeric/bindings/lapack/ppsv.hpp | 76 +-
sandbox/boost/numeric/bindings/lapack/ptsv.hpp | 56
sandbox/boost/numeric/bindings/lapack/spsv.hpp | 100 +-
sandbox/boost/numeric/bindings/lapack/steqr.hpp | 14
sandbox/boost/numeric/bindings/lapack/syev.hpp | 32
sandbox/boost/numeric/bindings/lapack/syevx.hpp | 2
sandbox/boost/numeric/bindings/lapack/sygv.hpp | 2
sandbox/boost/numeric/bindings/lapack/sysv.hpp | 188 ++--
sandbox/boost/numeric/bindings/lapack/sytrd.hpp | 16
sandbox/boost/numeric/bindings/lapack/trevc.hpp | 32
sandbox/boost/numeric/bindings/lapack/trexc.hpp | 40
sandbox/boost/numeric/bindings/traits/detail/utils.hpp | 14
sandbox/boost/numeric/bindings/traits/fortran.h | 6
sandbox/boost/numeric/bindings/traits/type.h | 12
48 files changed, 2206 insertions(+), 2188 deletions(-)
Modified: sandbox/boost/numeric/bindings/amos/amos.h
==============================================================================
--- sandbox/boost/numeric/bindings/amos/amos.h (original)
+++ sandbox/boost/numeric/bindings/amos/amos.h 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -14,17 +14,17 @@
extern "C"
{
- void AMOS_DBESI(const double* z, const double* fnu, const int* kode, const int* n, double* cy, int* nz ) ;
- void AMOS_CBESI(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, int* ierr) ;
- void AMOS_ZBESI(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, int* ierr) ;
+ void AMOS_DBESI(const double* z, const double* fnu, const integer_t* kode, const integer_t* n, double* cy, integer_t* nz ) ;
+ void AMOS_CBESI(const fcomplex_t* z, const float* fnu, const integer_t* kode, const integer_t* n, fcomplex_t* cy, integer_t* nz, integer_t* ierr) ;
+ void AMOS_ZBESI(const double* zr, const double* zi, const double* fnu, const integer_t* kode, const integer_t* n, double* cyr, double* cyi, integer_t* nz, integer_t* ierr) ;
- void AMOS_DBESJ(const double * z, const double* fnu, const int* n, double* cy, int* nz ) ;
- void AMOS_CBESJ(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, int* ierr) ;
- void AMOS_ZBESJ(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, int* ierr) ;
+ void AMOS_DBESJ(const double * z, const double* fnu, const integer_t* n, double* cy, integer_t* nz ) ;
+ void AMOS_CBESJ(const fcomplex_t* z, const float* fnu, const integer_t* kode, const integer_t* n, fcomplex_t* cy, integer_t* nz, integer_t* ierr) ;
+ void AMOS_ZBESJ(const double* zr, const double* zi, const double* fnu, const integer_t* kode, const integer_t* n, double* cyr, double* cyi, integer_t* nz, integer_t* ierr) ;
- void AMOS_DBESY(const double * z, const double* fnu, const int* n, double* cy ) ;
- void AMOS_CBESY(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, fcomplex_t *cwrk, int* ierr) ;
- void AMOS_ZBESY(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, double *cwrkr, double *cwrki, int* ierr) ;
+ void AMOS_DBESY(const double * z, const double* fnu, const integer_t* n, double* cy ) ;
+ void AMOS_CBESY(const fcomplex_t* z, const float* fnu, const integer_t* kode, const integer_t* n, fcomplex_t* cy, integer_t* nz, fcomplex_t *cwrk, integer_t* ierr) ;
+ void AMOS_ZBESY(const double* zr, const double* zi, const double* fnu, const integer_t* kode, const integer_t* n, double* cyr, double* cyi, integer_t* nz, double *cwrkr, double *cwrki, integer_t* ierr) ;
}
#endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP
Modified: sandbox/boost/numeric/bindings/amos/amos.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/amos/amos.hpp (original)
+++ sandbox/boost/numeric/bindings/amos/amos.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -20,9 +20,9 @@
template < typename vector_type, typename value_type >
int besi(const value_type& z, // std::complex< float > or std::complex< double >
const typename traits::type_traits< value_type >::real_type fnu, // float or double
- int kode,
+ integer_t kode,
vector_type& cy,
- int& nz)
+ integer_t& nz)
{
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits<vector_type>::value_type >::value ) ) ;
@@ -30,10 +30,10 @@
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ;
#endif
- int n = traits::vector_size( cy ) ;
+ integer_t n = traits::vector_size( cy ) ;
value_type * cy_ptr = traits::vector_storage( cy ) ;
- int error = 0 ;
+ integer_t error = 0 ;
detail::besi( z, fnu, kode, n, cy_ptr, nz, error ) ;
return error ;
}
@@ -41,9 +41,9 @@
template < typename vector_type, typename value_type >
int besj(const value_type& z,
const typename traits::type_traits< value_type >::real_type fnu,
- int kode,
+ integer_t kode,
vector_type& cy,
- int& nz)
+ integer_t& nz)
{
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits<vector_type>::value_type >::value ) ) ;
@@ -51,10 +51,10 @@
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ;
#endif
- int n = traits::vector_size( cy ) ;
+ integer_t n = traits::vector_size( cy ) ;
value_type * cy_ptr = traits::vector_storage( cy ) ;
- int error = 0 ;
+ integer_t error = 0 ;
detail::besj( z, fnu, kode, n, cy_ptr, nz, error ) ;
return error ;
}
@@ -62,9 +62,9 @@
template < typename vector_type, typename value_type >
int besy(const value_type& z,
const typename traits::type_traits< value_type >::real_type fnu,
- int kode,
+ integer_t kode,
vector_type& cy,
- int& nz)
+ integer_t& nz)
{
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits<vector_type>::value_type >::value ) ) ;
@@ -72,10 +72,10 @@
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ;
#endif
- int n = traits::vector_size( cy ) ;
+ integer_t n = traits::vector_size( cy ) ;
value_type * cy_ptr = traits::vector_storage( cy ) ;
- int error = 0 ;
+ integer_t error = 0 ;
value_type * cwrk = new value_type[n];
detail::besy( z, fnu, kode, n, cy_ptr, nz, cwrk, error ) ;
delete[] cwrk ;
Modified: sandbox/boost/numeric/bindings/amos/amos_overloads.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/amos/amos_overloads.hpp (original)
+++ sandbox/boost/numeric/bindings/amos/amos_overloads.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -22,29 +22,29 @@
//
//inline
- //void besi(const fcomplex * z, const fcomplex * fnu, const int * kode, const int * n, fcomplex* cy, int * nz, int * error) ;
+ //void besi(const fcomplex * z, const fcomplex * fnu, const integer_t * kode, const integer_t * n, fcomplex* cy, integer_t * nz, integer_t * error) ;
inline
- void besi(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, int& error)
+ void besi(const double& z, const double& fnu, const integer_t& kode, const integer_t& n, double* cy, integer_t& nz, integer_t& error)
{ AMOS_DBESI( &z, &fnu, &kode, &n, cy, &nz ) ; }
inline
- void besi(const complex_f& z, const float& fnu, const int& kode, const int& n, complex_f* cy, int & nz, int & error)
+ void besi(const complex_f& z, const float& fnu, const integer_t& kode, const integer_t& n, complex_f* cy, integer_t & nz, integer_t & error)
{ AMOS_CBESI( complex_ptr( &z ), &fnu, &kode, &n, complex_ptr( cy ), &nz, &error ) ; }
// inline
- // void besi(const complex_d* z, const double* fnu, const int * kode, const int * n, complex_d* cy, int * nz, int * error) ;
+ // void besi(const complex_d* z, const double* fnu, const integer_t * kode, const integer_t * n, complex_d* cy, integer_t * nz, integer_t * error) ;
//
// BESJ
//
inline
- void besj(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, int& error)
+ void besj(const double& z, const double& fnu, const integer_t& kode, const integer_t& n, double* cy, integer_t& nz, integer_t& error)
{ AMOS_DBESJ( &z, &fnu, &n, cy, &nz ) ; }
inline
- void besj(const complex_f& z, const float& fnu, const int& kode, const int& n, complex_f* cy, int & nz, int & error)
+ void besj(const complex_f& z, const float& fnu, const integer_t& kode, const integer_t& n, complex_f* cy, integer_t & nz, integer_t & error)
{ AMOS_CBESJ( complex_ptr( &z ), &fnu, &kode, &n, complex_ptr( cy ), &nz, &error ) ; }
@@ -54,7 +54,7 @@
//
inline
- void besy(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, double* wrk, int& error)
+ void besy(const double& z, const double& fnu, const integer_t& kode, const integer_t& n, double* cy, integer_t& nz, double* wrk, integer_t& error)
{ AMOS_DBESY( &z, &fnu, &n, cy ) ; }
}}}}}
Modified: sandbox/boost/numeric/bindings/blas/blas.h
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas.h (original)
+++ sandbox/boost/numeric/bindings/blas/blas.h 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -22,124 +22,124 @@
//
// Level 1
//
- void BLAS_SSCAL(const int *n, const float* alpha, float* x, const int* incx);
- void BLAS_DSCAL(const int *n, const double* alpha, double* x, const int* incx);
- void BLAS_CSCAL(const int *n, const fcomplex_t* alpha, fcomplex_t* x, const int* incx);
- void BLAS_ZSCAL(const int *n, const dcomplex_t* alpha, dcomplex_t* x, const int* incx);
+ void BLAS_SSCAL(const integer_t *n, const float* alpha, float* x, const integer_t* incx);
+ void BLAS_DSCAL(const integer_t *n, const double* alpha, double* x, const integer_t* incx);
+ void BLAS_CSCAL(const integer_t *n, const fcomplex_t* alpha, fcomplex_t* x, const integer_t* incx);
+ void BLAS_ZSCAL(const integer_t *n, const dcomplex_t* alpha, dcomplex_t* x, const integer_t* incx);
- void BLAS_SAXPY(const int *n, const float* alpha, const float* x, const int* incx, float* y, const int* incy);
- void BLAS_DAXPY(const int *n, const double* alpha, const double* x, const int* incx, double* y, const int* incy);
- void BLAS_CAXPY(const int *n, const fcomplex_t* alpha, const fcomplex_t* x, const int* incx, fcomplex_t* y, const int* incy);
- void BLAS_ZAXPY(const int *n, const dcomplex_t* alpha, const dcomplex_t* x, const int* incx, dcomplex_t* y, const int* incy);
+ void BLAS_SAXPY(const integer_t *n, const float* alpha, const float* x, const integer_t* incx, float* y, const integer_t* incy);
+ void BLAS_DAXPY(const integer_t *n, const double* alpha, const double* x, const integer_t* incx, double* y, const integer_t* incy);
+ void BLAS_CAXPY(const integer_t *n, const fcomplex_t* alpha, const fcomplex_t* x, const integer_t* incx, fcomplex_t* y, const integer_t* incy);
+ void BLAS_ZAXPY(const integer_t *n, const dcomplex_t* alpha, const dcomplex_t* x, const integer_t* incx, dcomplex_t* y, const integer_t* incy);
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- float BLAS_SDOT (const int *n, const float *x, const int *incx, const float *y, const int *incy);
+ float BLAS_SDOT (const integer_t *n, const float *x, const integer_t *incx, const float *y, const integer_t *incy);
#else
- double BLAS_SDOT (const int *n, const float *x, const int *incx, const float *y, const int *incy);
+ double BLAS_SDOT (const integer_t *n, const float *x, const integer_t *incx, const float *y, const integer_t *incy);
#endif
- double BLAS_DDOT (const int *n, const double *x, const int *incx, const double *y, const int *incy);
+ double BLAS_DDOT (const integer_t *n, const double *x, const integer_t *incx, const double *y, const integer_t *incy);
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- fcomplex_t BLAS_CDOTU(const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy);
+ fcomplex_t BLAS_CDOTU(const integer_t *n, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *y, const integer_t *incy);
#else
- void BLAS_CDOTU(fcomplex_t* ret, const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy);
+ void BLAS_CDOTU(fcomplex_t* ret, const integer_t *n, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *y, const integer_t *incy);
#endif
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- dcomplex_t BLAS_ZDOTU(const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy);
+ dcomplex_t BLAS_ZDOTU(const integer_t *n, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *y, const integer_t *incy);
#else
- void BLAS_ZDOTU(dcomplex_t* ret, const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy);
+ void BLAS_ZDOTU(dcomplex_t* ret, const integer_t *n, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *y, const integer_t *incy);
#endif
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- fcomplex_t BLAS_CDOTC(const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy);
+ fcomplex_t BLAS_CDOTC(const integer_t *n, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *y, const integer_t *incy);
#else
- void BLAS_CDOTC(fcomplex_t* ret, const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy);
+ void BLAS_CDOTC(fcomplex_t* ret, const integer_t *n, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *y, const integer_t *incy);
#endif
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- dcomplex_t BLAS_ZDOTC(const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy);
+ dcomplex_t BLAS_ZDOTC(const integer_t *n, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *y, const integer_t *incy);
#else
- void BLAS_ZDOTC(dcomplex_t* ret, const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy);
+ void BLAS_ZDOTC(dcomplex_t* ret, const integer_t *n, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *y, const integer_t *incy);
#endif
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- float BLAS_SNRM2(const int *n, const float *x, const int *incx);
+ float BLAS_SNRM2(const integer_t *n, const float *x, const integer_t *incx);
#else
- double BLAS_SNRM2(const int *n, const float *x, const int *incx);
+ double BLAS_SNRM2(const integer_t *n, const float *x, const integer_t *incx);
#endif
- double BLAS_DNRM2(const int *n, const double *x, const int *incx);
+ double BLAS_DNRM2(const integer_t *n, const double *x, const integer_t *incx);
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- float BLAS_SCNRM2(const int *n, const fcomplex_t *x, const int *incx);
+ float BLAS_SCNRM2(const integer_t *n, const fcomplex_t *x, const integer_t *incx);
#else
- double BLAS_SCNRM2(const int *n, const fcomplex_t *x, const int *incx);
+ double BLAS_SCNRM2(const integer_t *n, const fcomplex_t *x, const integer_t *incx);
#endif
- double BLAS_DZNRM2(const int *n, const dcomplex_t *x, const int *incx);
+ double BLAS_DZNRM2(const integer_t *n, const dcomplex_t *x, const integer_t *incx);
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- float BLAS_SASUM(const int *n, const float *x, const int *incx);
+ float BLAS_SASUM(const integer_t *n, const float *x, const integer_t *incx);
#else
- double BLAS_SASUM(const int *n, const float *x, const int *incx);
+ double BLAS_SASUM(const integer_t *n, const float *x, const integer_t *incx);
#endif
- double BLAS_DASUM(const int *n, const double *x, const int *incx);
+ double BLAS_DASUM(const integer_t *n, const double *x, const integer_t *incx);
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- float BLAS_SCASUM(const int *n, const fcomplex_t *x, const int *incx);
+ float BLAS_SCASUM(const integer_t *n, const fcomplex_t *x, const integer_t *incx);
#else
- double BLAS_SCASUM(const int *n, const fcomplex_t *x, const int *incx);
+ double BLAS_SCASUM(const integer_t *n, const fcomplex_t *x, const integer_t *incx);
#endif
- double BLAS_DZASUM(const int *n, const dcomplex_t *x, const int *incx);
+ double BLAS_DZASUM(const integer_t *n, const dcomplex_t *x, const integer_t *incx);
- void BLAS_SCOPY( const int *n, const float *x, const int *incx, float *y, const int *incy);
- void BLAS_DCOPY( const int *n, const double *x, const int *incx, double *y, const int *incy);
- void BLAS_CCOPY( const int *n, const fcomplex_t *x, const int *incx, fcomplex_t *y, const int *incy);
- void BLAS_ZCOPY( const int *n, const dcomplex_t *x, const int *incx, dcomplex_t *y, const int *incy);
+ void BLAS_SCOPY( const integer_t *n, const float *x, const integer_t *incx, float *y, const integer_t *incy);
+ void BLAS_DCOPY( const integer_t *n, const double *x, const integer_t *incx, double *y, const integer_t *incy);
+ void BLAS_CCOPY( const integer_t *n, const fcomplex_t *x, const integer_t *incx, fcomplex_t *y, const integer_t *incy);
+ void BLAS_ZCOPY( const integer_t *n, const dcomplex_t *x, const integer_t *incx, dcomplex_t *y, const integer_t *incy);
//
// Level 2
//
- void BLAS_SGEMV(const char *trans, const int *m, const int *n, const float *alpha, const float *a, const int *lda, const float *x, const int *incx, const float *beta, float *y, const int *incy) ;
- void BLAS_DGEMV(const char *trans, const int *m, const int *n, const double *alpha, const double *a, const int *lda, const double *x, const int *incx, const double *beta, double *y, const int *incy) ;
- void BLAS_CGEMV(const char *trans, const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *a, const int *lda, const fcomplex_t *x, const int *incx, const fcomplex_t *beta, fcomplex_t *y, const int *incy) ;
- void BLAS_ZGEMV(const char *trans, const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *a, const int *lda, const dcomplex_t *x, const int *incx, const dcomplex_t *beta, dcomplex_t *y, const int *incy) ;
+ void BLAS_SGEMV(const char *trans, const integer_t *m, const integer_t *n, const float *alpha, const float *a, const integer_t *lda, const float *x, const integer_t *incx, const float *beta, float *y, const integer_t *incy) ;
+ void BLAS_DGEMV(const char *trans, const integer_t *m, const integer_t *n, const double *alpha, const double *a, const integer_t *lda, const double *x, const integer_t *incx, const double *beta, double *y, const integer_t *incy) ;
+ void BLAS_CGEMV(const char *trans, const integer_t *m, const integer_t *n, const fcomplex_t *alpha, const fcomplex_t *a, const integer_t *lda, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *beta, fcomplex_t *y, const integer_t *incy) ;
+ void BLAS_ZGEMV(const char *trans, const integer_t *m, const integer_t *n, const dcomplex_t *alpha, const dcomplex_t *a, const integer_t *lda, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *beta, dcomplex_t *y, const integer_t *incy) ;
- void BLAS_SGER (const int *m, const int *n, const float * alpha, const float * x, const int *incx, const float * y, const int *incy, float *a, const int *lda);
- void BLAS_DGER (const int *m, const int *n, const double *alpha, const double *x, const int *incx, const double *y, const int *incy, double *a, const int *lda);
+ void BLAS_SGER (const integer_t *m, const integer_t *n, const float * alpha, const float * x, const integer_t *incx, const float * y, const integer_t *incy, float *a, const integer_t *lda);
+ void BLAS_DGER (const integer_t *m, const integer_t *n, const double *alpha, const double *x, const integer_t *incx, const double *y, const integer_t *incy, double *a, const integer_t *lda);
- void BLAS_CGERU(const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy, fcomplex_t *a, const int *lda);
- void BLAS_ZGERU(const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy, dcomplex_t *a, const int *lda);
+ void BLAS_CGERU(const integer_t *m, const integer_t *n, const fcomplex_t *alpha, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *y, const integer_t *incy, fcomplex_t *a, const integer_t *lda);
+ void BLAS_ZGERU(const integer_t *m, const integer_t *n, const dcomplex_t *alpha, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *y, const integer_t *incy, dcomplex_t *a, const integer_t *lda);
- void BLAS_CGERC(const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy, fcomplex_t *a, const int *lda);
- void BLAS_ZGERC(const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy, dcomplex_t *a, const int *lda);
+ void BLAS_CGERC(const integer_t *m, const integer_t *n, const fcomplex_t *alpha, const fcomplex_t *x, const integer_t *incx, const fcomplex_t *y, const integer_t *incy, fcomplex_t *a, const integer_t *lda);
+ void BLAS_ZGERC(const integer_t *m, const integer_t *n, const dcomplex_t *alpha, const dcomplex_t *x, const integer_t *incx, const dcomplex_t *y, const integer_t *incy, dcomplex_t *a, const integer_t *lda);
//
// Level 3
//
- void BLAS_SGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const float *alpha, const float *a, const int *lda, const float *b, const int *ldb, const float *beta, float *c, const int *ldc);
- void BLAS_DGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const double *alpha, const double *a, const int *lda, const double *b, const int *ldb, const double *beta, double *c, const int *ldc);
- void BLAS_CGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const fcomplex_t *alpha, const fcomplex_t *a, const int *lda, const fcomplex_t *b, const int *ldb, const fcomplex_t *beta, fcomplex_t *c, const int *ldc);
- void BLAS_ZGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const dcomplex_t *alpha, const dcomplex_t *a, const int *lda, const dcomplex_t *b, const int *ldb, const dcomplex_t *beta, dcomplex_t *c, const int *ldc);
-
- void BLAS_SSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const float* alpha,
- const float* a, const int* lda, const float* beta, float* c, const int* ldc );
- void BLAS_DSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const double* alpha,
- const double* a, const int* lda, const double* beta, double* c, const int* ldc );
- void BLAS_CSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const fcomplex_t* alpha,
- const fcomplex_t* a, const int* lda, const fcomplex_t* beta, fcomplex_t* c, const int* ldc );
- void BLAS_ZSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const dcomplex_t* alpha,
- const dcomplex_t* a, const int* lda, const dcomplex_t* beta, dcomplex_t* c, const int* ldc );
- void BLAS_CHERK ( const char* uplo, const char* trans, const int* n, const int* k, const float* alpha,
- const fcomplex_t* a, const int* lda, const float* beta, fcomplex_t* c, const int* ldc );
- void BLAS_ZHERK ( const char* uplo, const char* trans, const int* n, const int* k, const double* alpha,
- const dcomplex_t* a, const int* lda, const double* beta, dcomplex_t* c, const int* ldc );
-
- void BLAS_STRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m,
- const int* n, float const* alpha, float const* a, int const* lda, float* b, int const* ldb );
- void BLAS_DTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m,
- const int* n, double const* alpha, double const* a, int const* lda, double* b, int const* ldb );
- void BLAS_CTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m,
- const int* n, fcomplex_t const* alpha, fcomplex_t const* a, int const* lda, fcomplex_t* b, int const* ldb );
- void BLAS_ZTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m,
- const int* n, dcomplex_t const* alpha, dcomplex_t const* a, int const* lda, dcomplex_t* b, int const* ldb );
+ void BLAS_SGEMM(const char *transa, const char *transb, const integer_t *m, const integer_t *n, const integer_t *k, const float *alpha, const float *a, const integer_t *lda, const float *b, const integer_t *ldb, const float *beta, float *c, const integer_t *ldc);
+ void BLAS_DGEMM(const char *transa, const char *transb, const integer_t *m, const integer_t *n, const integer_t *k, const double *alpha, const double *a, const integer_t *lda, const double *b, const integer_t *ldb, const double *beta, double *c, const integer_t *ldc);
+ void BLAS_CGEMM(const char *transa, const char *transb, const integer_t *m, const integer_t *n, const integer_t *k, const fcomplex_t *alpha, const fcomplex_t *a, const integer_t *lda, const fcomplex_t *b, const integer_t *ldb, const fcomplex_t *beta, fcomplex_t *c, const integer_t *ldc);
+ void BLAS_ZGEMM(const char *transa, const char *transb, const integer_t *m, const integer_t *n, const integer_t *k, const dcomplex_t *alpha, const dcomplex_t *a, const integer_t *lda, const dcomplex_t *b, const integer_t *ldb, const dcomplex_t *beta, dcomplex_t *c, const integer_t *ldc);
+
+ void BLAS_SSYRK ( const char* uplo, const char* trans, const integer_t* n, const integer_t* k, const float* alpha,
+ const float* a, const integer_t* lda, const float* beta, float* c, const integer_t* ldc );
+ void BLAS_DSYRK ( const char* uplo, const char* trans, const integer_t* n, const integer_t* k, const double* alpha,
+ const double* a, const integer_t* lda, const double* beta, double* c, const integer_t* ldc );
+ void BLAS_CSYRK ( const char* uplo, const char* trans, const integer_t* n, const integer_t* k, const fcomplex_t* alpha,
+ const fcomplex_t* a, const integer_t* lda, const fcomplex_t* beta, fcomplex_t* c, const integer_t* ldc );
+ void BLAS_ZSYRK ( const char* uplo, const char* trans, const integer_t* n, const integer_t* k, const dcomplex_t* alpha,
+ const dcomplex_t* a, const integer_t* lda, const dcomplex_t* beta, dcomplex_t* c, const integer_t* ldc );
+ void BLAS_CHERK ( const char* uplo, const char* trans, const integer_t* n, const integer_t* k, const float* alpha,
+ const fcomplex_t* a, const integer_t* lda, const float* beta, fcomplex_t* c, const integer_t* ldc );
+ void BLAS_ZHERK ( const char* uplo, const char* trans, const integer_t* n, const integer_t* k, const double* alpha,
+ const dcomplex_t* a, const integer_t* lda, const double* beta, dcomplex_t* c, const integer_t* ldc );
+
+ void BLAS_STRSM( const char* side, const char* uplo, const char* transa, const char* diag, const integer_t* m,
+ const integer_t* n, float const* alpha, float const* a, integer_t const* lda, float* b, integer_t const* ldb );
+ void BLAS_DTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const integer_t* m,
+ const integer_t* n, double const* alpha, double const* a, integer_t const* lda, double* b, integer_t const* ldb );
+ void BLAS_CTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const integer_t* m,
+ const integer_t* n, fcomplex_t const* alpha, fcomplex_t const* a, integer_t const* lda, fcomplex_t* b, integer_t const* ldb );
+ void BLAS_ZTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const integer_t* m,
+ const integer_t* n, dcomplex_t const* alpha, dcomplex_t const* a, integer_t const* lda, dcomplex_t* b, integer_t const* ldb );
}
Modified: sandbox/boost/numeric/bindings/blas/blas1.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas1.hpp (original)
+++ sandbox/boost/numeric/bindings/blas/blas1.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -27,10 +27,10 @@
BOOST_STATIC_ASSERT( ( boost::is_same< typename vector_x_type::value_type, typename vector_y_type::value_type >::value ) ) ;
#endif
- const int n = traits::vector_size( x ) ;
+ const integer_t n = traits::vector_size( x ) ;
assert( n==traits::vector_size( y ) ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
typename traits::vector_traits<vector_x_type>::value_type const *x_ptr = traits::vector_storage( x ) ;
typename traits::vector_traits<vector_y_type>::value_type *y_ptr = traits::vector_storage( y ) ;
@@ -48,8 +48,8 @@
BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ;
#endif
- const int n = traits::vector_size( x ) ;
- const int stride = traits::vector_stride( x ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride = traits::vector_stride( x ) ;
value_type *x_ptr = traits::vector_storage( x ) ;
detail::scal( n, alpha, x_ptr, stride ) ;
@@ -69,9 +69,9 @@
#endif
assert( traits::vector_size( x ) == traits::vector_size( y ) ) ;
- const int n = traits::vector_size( x ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
value_type *y_ptr = traits::vector_storage( y ) ;
@@ -104,9 +104,9 @@
#endif
value_type ;
- const int n = traits::vector_size( x ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
const value_type *y_ptr = traits::vector_storage( y ) ;
@@ -138,9 +138,9 @@
#endif
value_type ;
- const int n = traits::vector_size( x ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
const value_type *y_ptr = traits::vector_storage( y ) ;
@@ -173,9 +173,9 @@
#endif
value_type ;
- const int n = traits::vector_size( x ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
const value_type *y_ptr = traits::vector_storage( y ) ;
@@ -199,8 +199,8 @@
#else
typedef vector_type::value_type value_type ;
#endif
- const int n = traits::vector_size( x ) ;
- const int stride_x = traits::vector_stride( x ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
return detail::nrm2( n, x_ptr, stride_x ) ;
@@ -224,8 +224,8 @@
typedef vector_type::value_type value_type ;
#endif
- const int n = traits::vector_size( x ) ;
- const int stride_x = traits::vector_stride( x ) ;
+ const integer_t n = traits::vector_size( x ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
return detail::asum( n, x_ptr, stride_x ) ;
Modified: sandbox/boost/numeric/bindings/blas/blas1_overloads.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas1_overloads.hpp (original)
+++ sandbox/boost/numeric/bindings/blas/blas1_overloads.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -18,62 +18,62 @@
using namespace boost::numeric::bindings::traits ;
// x *= alpha
- inline void scal(const int& n, const float& alpha, float* x, const int& incx) { BLAS_SSCAL( &n, &alpha, x , &incx ) ; }
- inline void scal(const int& n, const double& alpha, double* x, const int& incx) { BLAS_DSCAL( &n, &alpha, x , &incx ) ; }
- inline void scal(const int& n, const complex_f& alpha, complex_f* x, const int& incx) { BLAS_CSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; }
- inline void scal(const int& n, const complex_d& alpha, complex_d* x, const int& incx) { BLAS_ZSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; }
+ inline void scal(const integer_t& n, const float& alpha, float* x, const integer_t& incx) { BLAS_SSCAL( &n, &alpha, x , &incx ) ; }
+ inline void scal(const integer_t& n, const double& alpha, double* x, const integer_t& incx) { BLAS_DSCAL( &n, &alpha, x , &incx ) ; }
+ inline void scal(const integer_t& n, const complex_f& alpha, complex_f* x, const integer_t& incx) { BLAS_CSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; }
+ inline void scal(const integer_t& n, const complex_d& alpha, complex_d* x, const integer_t& incx) { BLAS_ZSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; }
// y += alpha * x
- inline void axpy(const int& n, const float & alpha, const float * x, const int& incx, float * y, const int& incy) { BLAS_SAXPY( &n, &alpha , x , &incx, y , &incy ) ; }
- inline void axpy(const int& n, const double & alpha, const double * x, const int& incx, double * y, const int& incy) { BLAS_DAXPY( &n, &alpha , x , &incx, y , &incy ) ; }
- inline void axpy(const int& n, const complex_f& alpha, const complex_f* x, const int& incx, complex_f* y, const int& incy) { BLAS_CAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
- inline void axpy(const int& n, const complex_d& alpha, const complex_d* x, const int& incx, complex_d* y, const int& incy) { BLAS_ZAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
+ inline void axpy(const integer_t& n, const float & alpha, const float * x, const integer_t& incx, float * y, const integer_t& incy) { BLAS_SAXPY( &n, &alpha , x , &incx, y , &incy ) ; }
+ inline void axpy(const integer_t& n, const double & alpha, const double * x, const integer_t& incx, double * y, const integer_t& incy) { BLAS_DAXPY( &n, &alpha , x , &incx, y , &incy ) ; }
+ inline void axpy(const integer_t& n, const complex_f& alpha, const complex_f* x, const integer_t& incx, complex_f* y, const integer_t& incy) { BLAS_CAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
+ inline void axpy(const integer_t& n, const complex_d& alpha, const complex_d* x, const integer_t& incx, complex_d* y, const integer_t& incy) { BLAS_ZAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
// x^T . y
- inline float dot(const int& n, const float * x, const int& incx, const float * y, const int& incy) { return BLAS_SDOT( &n, x, &incx, y, &incy ) ; }
- inline double dot(const int& n, const double* x, const int& incx, const double* y, const int& incy) { return BLAS_DDOT( &n, x, &incx, y, &incy ) ; }
+ inline float dot(const integer_t& n, const float * x, const integer_t& incx, const float * y, const integer_t& incy) { return BLAS_SDOT( &n, x, &incx, y, &incy ) ; }
+ inline double dot(const integer_t& n, const double* x, const integer_t& incx, const double* y, const integer_t& incy) { return BLAS_DDOT( &n, x, &incx, y, &incy ) ; }
// x^T . y
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- inline void dotu(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { ret = complex_ret( BLAS_CDOTU( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
+ inline void dotu(complex_f& ret, const integer_t& n, const complex_f* x, const integer_t& incx, const complex_f* y, const integer_t& incy) { ret = complex_ret( BLAS_CDOTU( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
#else
- inline void dotu(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { BLAS_CDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
+ inline void dotu(complex_f& ret, const integer_t& n, const complex_f* x, const integer_t& incx, const complex_f* y, const integer_t& incy) { BLAS_CDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
#endif
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- inline void dotu(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { ret = complex_ret( BLAS_ZDOTU( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
+ inline void dotu(complex_d& ret, const integer_t& n, const complex_d* x, const integer_t& incx, const complex_d* y, const integer_t& incy) { ret = complex_ret( BLAS_ZDOTU( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
#else
- inline void dotu(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { BLAS_ZDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
+ inline void dotu(complex_d& ret, const integer_t& n, const complex_d* x, const integer_t& incx, const complex_d* y, const integer_t& incy) { BLAS_ZDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
#endif
// x^H . y
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- inline void dotc(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { ret = complex_ret( BLAS_CDOTC( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
+ inline void dotc(complex_f& ret, const integer_t& n, const complex_f* x, const integer_t& incx, const complex_f* y, const integer_t& incy) { ret = complex_ret( BLAS_CDOTC( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
#else
- inline void dotc(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { BLAS_CDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
+ inline void dotc(complex_f& ret, const integer_t& n, const complex_f* x, const integer_t& incx, const complex_f* y, const integer_t& incy) { BLAS_CDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
#endif
#ifndef BIND_FORTRAN_F2C_RETURN_CONVENTIONS
- inline void dotc(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { ret = complex_ret( BLAS_ZDOTC( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
+ inline void dotc(complex_d& ret, const integer_t& n, const complex_d* x, const integer_t& incx, const complex_d* y, const integer_t& incy) { ret = complex_ret( BLAS_ZDOTC( &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ) ; }
#else
- inline void dotc(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { BLAS_ZDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
+ inline void dotc(complex_d& ret, const integer_t& n, const complex_d* x, const integer_t& incx, const complex_d* y, const integer_t& incy) { BLAS_ZDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; }
#endif
// euclidean norm
- inline float nrm2(const int& n, const float* x, const int& incx) { return BLAS_SNRM2( &n, x, &incx ) ; }
- inline double nrm2(const int& n, const double* x, const int& incx) { return BLAS_DNRM2( &n, x, &incx ) ; }
- inline float nrm2(const int& n, const complex_f* x, const int& incx) { return BLAS_SCNRM2( &n, complex_ptr(x), &incx ) ; }
- inline double nrm2(const int& n, const complex_d* x, const int& incx) { return BLAS_DZNRM2( &n, complex_ptr(x), &incx ) ; }
+ inline float nrm2(const integer_t& n, const float* x, const integer_t& incx) { return BLAS_SNRM2( &n, x, &incx ) ; }
+ inline double nrm2(const integer_t& n, const double* x, const integer_t& incx) { return BLAS_DNRM2( &n, x, &incx ) ; }
+ inline float nrm2(const integer_t& n, const complex_f* x, const integer_t& incx) { return BLAS_SCNRM2( &n, complex_ptr(x), &incx ) ; }
+ inline double nrm2(const integer_t& n, const complex_d* x, const integer_t& incx) { return BLAS_DZNRM2( &n, complex_ptr(x), &incx ) ; }
// 1-norm
- inline float asum(const int& n, const float* x, const int& incx) { return BLAS_SASUM( &n, x, &incx ) ; }
- inline double asum(const int& n, const double* x, const int& incx) { return BLAS_DASUM( &n, x, &incx ) ; }
- inline float asum(const int& n, const complex_f* x, const int& incx) { return BLAS_SCASUM( &n, complex_ptr(x), &incx ) ; }
- inline double asum(const int& n, const complex_d* x, const int& incx) { return BLAS_DZASUM( &n, complex_ptr(x), &incx ) ; }
+ inline float asum(const integer_t& n, const float* x, const integer_t& incx) { return BLAS_SASUM( &n, x, &incx ) ; }
+ inline double asum(const integer_t& n, const double* x, const integer_t& incx) { return BLAS_DASUM( &n, x, &incx ) ; }
+ inline float asum(const integer_t& n, const complex_f* x, const integer_t& incx) { return BLAS_SCASUM( &n, complex_ptr(x), &incx ) ; }
+ inline double asum(const integer_t& n, const complex_d* x, const integer_t& incx) { return BLAS_DZASUM( &n, complex_ptr(x), &incx ) ; }
// copy
- inline void copy(const int& n, const float* x, const int& incx, float* y, const int& incy) { BLAS_SCOPY( &n, x, &incx, y, &incy ) ; }
- inline void copy(const int& n, const double* x, const int& incx, double* y, const int& incy) { BLAS_DCOPY( &n, x, &incx, y, &incy ) ; }
- inline void copy(const int& n, const complex_f* x, const int& incx, complex_f* y, const int& incy) { BLAS_CCOPY( &n, complex_ptr(x), &incx, complex_ptr(y), &incy ) ; }
- inline void copy(const int& n, const complex_d* x, const int& incx, complex_d* y, const int& incy) { BLAS_ZCOPY( &n, complex_ptr(x), &incx, complex_ptr(y), &incy ) ; }
+ inline void copy(const integer_t& n, const float* x, const integer_t& incx, float* y, const integer_t& incy) { BLAS_SCOPY( &n, x, &incx, y, &incy ) ; }
+ inline void copy(const integer_t& n, const double* x, const integer_t& incx, double* y, const integer_t& incy) { BLAS_DCOPY( &n, x, &incx, y, &incy ) ; }
+ inline void copy(const integer_t& n, const complex_f* x, const integer_t& incx, complex_f* y, const integer_t& incy) { BLAS_CCOPY( &n, complex_ptr(x), &incx, complex_ptr(y), &incy ) ; }
+ inline void copy(const integer_t& n, const complex_d* x, const integer_t& incx, complex_d* y, const integer_t& incy) { BLAS_ZCOPY( &n, complex_ptr(x), &incx, complex_ptr(y), &incy ) ; }
}}}}}
#endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP
Modified: sandbox/boost/numeric/bindings/blas/blas2.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas2.hpp (original)
+++ sandbox/boost/numeric/bindings/blas/blas2.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -37,13 +37,13 @@
>::value ) ) ;
*/
- const int m = traits::matrix_size1( a ) ;
- const int n = traits::matrix_size2( a ) ;
+ const integer_t m = traits::matrix_size1( a ) ;
+ const integer_t n = traits::matrix_size2( a ) ;
assert ( traits::vector_size( x ) >= (TRANS == traits::NO_TRANSPOSE ? n : m) ) ;
assert ( traits::vector_size( y ) >= (TRANS == traits::NO_TRANSPOSE ? m : n) ) ;
- const int lda = traits::leading_dimension( a ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t lda = traits::leading_dimension( a ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *a_ptr = traits::matrix_storage( a ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
@@ -68,13 +68,13 @@
>::value ) ) ;
*/
- const int m = traits::matrix_size1( a ) ;
- const int n = traits::matrix_size2( a ) ;
+ const integer_t m = traits::matrix_size1( a ) ;
+ const integer_t n = traits::matrix_size2( a ) ;
assert ( traits::vector_size( x ) <= m ) ;
assert ( traits::vector_size( y ) <= n ) ;
- const int lda = traits::leading_dimension( a ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t lda = traits::leading_dimension( a ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
const value_type *y_ptr = traits::vector_storage( y ) ;
@@ -99,13 +99,13 @@
// BOOST_STATIC_ASSERT( ( boost::is_same< x.value_type(), FEMTown::Complex() >::value ) ) ;
- const int m = traits::matrix_size1( a ) ;
- const int n = traits::matrix_size2( a ) ;
+ const integer_t m = traits::matrix_size1( a ) ;
+ const integer_t n = traits::matrix_size2( a ) ;
assert ( traits::vector_size( x ) <= m ) ;
assert ( traits::vector_size( y ) <= n ) ;
- const int lda = traits::leading_dimension( a ) ;
- const int stride_x = traits::vector_stride( x ) ;
- const int stride_y = traits::vector_stride( y ) ;
+ const integer_t lda = traits::leading_dimension( a ) ;
+ const integer_t stride_x = traits::vector_stride( x ) ;
+ const integer_t stride_y = traits::vector_stride( y ) ;
const value_type *x_ptr = traits::vector_storage( x ) ;
const value_type *y_ptr = traits::vector_storage( y ) ;
Modified: sandbox/boost/numeric/bindings/blas/blas2_overloads.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas2_overloads.hpp (original)
+++ sandbox/boost/numeric/bindings/blas/blas2_overloads.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -17,23 +17,23 @@
using namespace boost::numeric::bindings::traits ;
inline
- void gemv( char TRANS, const int& m, const int& n, const float & alpha, const float * a_ptr, const int& lda, const float * x_ptr, const int& incx, const float & beta, float * y_ptr, const int& incy ) { BLAS_SGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; }
+ void gemv( char TRANS, const integer_t& m, const integer_t& n, const float & alpha, const float * a_ptr, const integer_t& lda, const float * x_ptr, const integer_t& incx, const float & beta, float * y_ptr, const integer_t& incy ) { BLAS_SGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; }
inline
- void gemv( char TRANS, const int& m, const int& n, const double & alpha, const double * a_ptr, const int& lda, const double * x_ptr, const int& incx, const double & beta, double * y_ptr, const int& incy ) { BLAS_DGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; }
+ void gemv( char TRANS, const integer_t& m, const integer_t& n, const double & alpha, const double * a_ptr, const integer_t& lda, const double * x_ptr, const integer_t& incx, const double & beta, double * y_ptr, const integer_t& incy ) { BLAS_DGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; }
inline
- void gemv( char TRANS, const int& m, const int& n, const complex_f& alpha, const complex_f* a_ptr, const int& lda, const complex_f* x_ptr, const int& incx, const complex_f& beta, complex_f* y_ptr, const int& incy ) { BLAS_CGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; }
+ void gemv( char TRANS, const integer_t& m, const integer_t& n, const complex_f& alpha, const complex_f* a_ptr, const integer_t& lda, const complex_f* x_ptr, const integer_t& incx, const complex_f& beta, complex_f* y_ptr, const integer_t& incy ) { BLAS_CGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; }
inline
- void gemv( char TRANS, const int& m, const int& n, const complex_d& alpha, const complex_d* a_ptr, const int& lda, const complex_d* x_ptr, const int& incx, const complex_d& beta, complex_d* y_ptr, const int& incy ) { BLAS_ZGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; }
+ void gemv( char TRANS, const integer_t& m, const integer_t& n, const complex_d& alpha, const complex_d* a_ptr, const integer_t& lda, const complex_d* x_ptr, const integer_t& incx, const complex_d& beta, complex_d* y_ptr, const integer_t& incy ) { BLAS_ZGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; }
inline
- void ger( const int& m, const int& n, const float & alpha, const float * x_ptr, const int& incx, const float * y_ptr, const int& incy, float * a_ptr, const int& lda ) { BLAS_SGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; }
+ void ger( const integer_t& m, const integer_t& n, const float & alpha, const float * x_ptr, const integer_t& incx, const float * y_ptr, const integer_t& incy, float * a_ptr, const integer_t& lda ) { BLAS_SGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; }
inline
- void ger( const int& m, const int& n, const double & alpha, const double * x_ptr, const int& incx, const double * y_ptr, const int& incy, double * a_ptr, const int& lda ) { BLAS_DGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; }
+ void ger( const integer_t& m, const integer_t& n, const double & alpha, const double * x_ptr, const integer_t& incx, const double * y_ptr, const integer_t& incy, double * a_ptr, const integer_t& lda ) { BLAS_DGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; }
/*
inline
- void geru( const int& m, const int& n, const complex_f & alpha, const complex_f * x_ptr, const int& incx, complex_f * y_ptr, const int& incy, complex_f * a_ptr, const int& lda ) { BLAS_CGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; }
+ void geru( const integer_t& m, const integer_t& n, const complex_f & alpha, const complex_f * x_ptr, const integer_t& incx, complex_f * y_ptr, const integer_t& incy, complex_f * a_ptr, const integer_t& lda ) { BLAS_CGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; }
inline
- void geru( const int& m, const int& n, const complex_d & alpha, const complex_d * x_ptr, const int& incx, complex_d * y_ptr, const int& incy, complex_d * a_ptr, const int& lda ) { BLAS_ZGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; }
+ void geru( const integer_t& m, const integer_t& n, const complex_d & alpha, const complex_d * x_ptr, const integer_t& incx, complex_d * y_ptr, const integer_t& incy, complex_d * a_ptr, const integer_t& lda ) { BLAS_ZGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; }
*/
}}}}}
Modified: sandbox/boost/numeric/bindings/blas/blas3.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas3.hpp (original)
+++ sandbox/boost/numeric/bindings/blas/blas3.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -27,15 +27,15 @@
matrix_type_c &c
)
{
- const int m = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ;
- const int n = TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size2( b ) : traits::matrix_size1( b );
- const int k = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ;
+ const integer_t m = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ;
+ const integer_t n = TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size2( b ) : traits::matrix_size1( b );
+ const integer_t k = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ;
assert( k == ( TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size1( b ) : traits::matrix_size2( b ) ) ) ;
assert( m == traits::matrix_size1( c ) );
assert( n == traits::matrix_size2( c ) );
- const int lda = traits::leading_dimension( a );
- const int ldb = traits::leading_dimension( b );
- const int ldc = traits::leading_dimension( c );
+ const integer_t lda = traits::leading_dimension( a );
+ const integer_t ldb = traits::leading_dimension( b );
+ const integer_t ldc = traits::leading_dimension( c );
const value_type *a_ptr = traits::matrix_storage( a ) ;
const value_type *b_ptr = traits::matrix_storage( b ) ;
@@ -75,12 +75,12 @@
template < typename value_type, typename matrix_type_a, typename matrix_type_c >
void syrk( char uplo, char trans, const value_type& alpha, const matrix_type_a& a,
const value_type& beta, matrix_type_c& c) {
- const int n = traits::matrix_size1( c );
+ const integer_t n = traits::matrix_size1( c );
assert( n == traits::matrix_size2( c ) );
- const int k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ;
+ const integer_t k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ;
assert( n == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) );
- const int lda = traits::leading_dimension( a );
- const int ldc = traits::leading_dimension( c );
+ const integer_t lda = traits::leading_dimension( a );
+ const integer_t ldc = traits::leading_dimension( c );
const value_type *a_ptr = traits::matrix_storage( a ) ;
value_type *c_ptr = traits::matrix_storage( c ) ;
@@ -96,12 +96,12 @@
const real_type& beta, matrix_type_c& c) {
typedef typename matrix_type_c::value_type value_type ;
- const int n = traits::matrix_size1( c );
+ const integer_t n = traits::matrix_size1( c );
assert( n == traits::matrix_size2( c ) );
- const int k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ;
+ const integer_t k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ;
assert( n == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) );
- const int lda = traits::leading_dimension( a );
- const int ldc = traits::leading_dimension( c );
+ const integer_t lda = traits::leading_dimension( a );
+ const integer_t ldc = traits::leading_dimension( c );
const value_type *a_ptr = traits::matrix_storage( a ) ;
value_type *c_ptr = traits::matrix_storage( c ) ;
@@ -114,8 +114,8 @@
// op( A ) = A, A^T, A^H
template < class T, class A, class B >
void trsm( char side, char uplo, char transa, char diag, T const& alpha, A const& a, B& b ) {
- const int m = traits::matrix_size1( b ) ;
- const int n = traits::matrix_size2( b ) ;
+ const integer_t m = traits::matrix_size1( b ) ;
+ const integer_t n = traits::matrix_size2( b ) ;
assert( ( side=='L' && m==traits::matrix_size2( a ) && m==traits::matrix_size1( a ) ) ||
( side=='R' && n==traits::matrix_size2( a ) && n==traits::matrix_size1( a ) ) ) ;
assert( side=='R' || side=='L' ) ;
Modified: sandbox/boost/numeric/bindings/blas/blas3_overloads.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/blas/blas3_overloads.hpp (original)
+++ sandbox/boost/numeric/bindings/blas/blas3_overloads.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -17,47 +17,47 @@
using namespace boost::numeric::bindings::traits ;
inline
- void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const float & alpha, const float * a_ptr, const int& lda, const float * b_ptr, const int& ldb, const float & beta, float * c_ptr, const int& ldc ) { BLAS_SGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; }
+ void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const float & alpha, const float * a_ptr, const integer_t& lda, const float * b_ptr, const integer_t& ldb, const float & beta, float * c_ptr, const integer_t& ldc ) { BLAS_SGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; }
inline
- void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const double & alpha, const double * a_ptr, const int& lda, const double * b_ptr, const int& ldb, const double & beta, double * c_ptr, const int& ldc ) { BLAS_DGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; }
+ void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const double & alpha, const double * a_ptr, const integer_t& lda, const double * b_ptr, const integer_t& ldb, const double & beta, double * c_ptr, const integer_t& ldc ) { BLAS_DGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; }
inline
- void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const complex_f& alpha, const complex_f* a_ptr, const int& lda, const complex_f* b_ptr, const int& ldb, const complex_f& beta, complex_f* c_ptr, const int& ldc ) { BLAS_CGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; }
+ void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const complex_f& alpha, const complex_f* a_ptr, const integer_t& lda, const complex_f* b_ptr, const integer_t& ldb, const complex_f& beta, complex_f* c_ptr, const integer_t& ldc ) { BLAS_CGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; }
inline
- void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const complex_d& alpha, const complex_d* a_ptr, const int& lda, const complex_d* b_ptr, const int& ldb, const complex_d& beta, complex_d* c_ptr, const int& ldc ) { BLAS_ZGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; }
+ void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const complex_d& alpha, const complex_d* a_ptr, const integer_t& lda, const complex_d* b_ptr, const integer_t& ldb, const complex_d& beta, complex_d* c_ptr, const integer_t& ldc ) { BLAS_ZGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; }
//
// SYRK
//
inline
- void syrk( char uplo, char trans, const int& n, const int& k, const float& alpha,
- const float* a_ptr, const int lda, const float& beta, float* c_ptr,
- const int& ldc)
+ void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const float& alpha,
+ const float* a_ptr, const integer_t lda, const float& beta, float* c_ptr,
+ const integer_t& ldc)
{
BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);
}
inline
- void syrk( char uplo, char trans, const int& n, const int& k, const double& alpha,
- const double* a_ptr, const int lda, const double& beta, double* c_ptr,
- const int& ldc)
+ void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const double& alpha,
+ const double* a_ptr, const integer_t lda, const double& beta, double* c_ptr,
+ const integer_t& ldc)
{
BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);
}
inline
- void syrk( char uplo, char trans, const int& n, const int& k, const complex_f& alpha,
- const complex_f* a_ptr, const int lda, const complex_f& beta, complex_f* c_ptr,
- const int& ldc)
+ void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const complex_f& alpha,
+ const complex_f* a_ptr, const integer_t lda, const complex_f& beta, complex_f* c_ptr,
+ const integer_t& ldc)
{
BLAS_CSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ),
&lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc);
}
inline
- void syrk( char uplo, char trans, const int& n, const int& k, const complex_d& alpha,
- const complex_d* a_ptr, const int lda, const complex_d& beta, complex_d* c_ptr,
- const int& ldc)
+ void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const complex_d& alpha,
+ const complex_d* a_ptr, const integer_t lda, const complex_d& beta, complex_d* c_ptr,
+ const integer_t& ldc)
{
BLAS_ZSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ),
&lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc);
@@ -67,35 +67,35 @@
// HERK
//
inline
- void herk( char uplo, char trans, const int& n, const int& k, const float& alpha,
- const float* a_ptr, const int lda, const float& beta, float* c_ptr,
- const int& ldc)
+ void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const float& alpha,
+ const float* a_ptr, const integer_t lda, const float& beta, float* c_ptr,
+ const integer_t& ldc)
{
BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);
}
inline
- void herk( char uplo, char trans, const int& n, const int& k, const double& alpha,
- const double* a_ptr, const int lda, const double& beta, double* c_ptr,
- const int& ldc)
+ void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const double& alpha,
+ const double* a_ptr, const integer_t lda, const double& beta, double* c_ptr,
+ const integer_t& ldc)
{
BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);
}
inline
- void herk( char uplo, char trans, const int& n, const int& k, const float& alpha,
- const complex_f* a_ptr, const int lda, const float& beta, complex_f* c_ptr,
- const int& ldc)
+ void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const float& alpha,
+ const complex_f* a_ptr, const integer_t lda, const float& beta, complex_f* c_ptr,
+ const integer_t& ldc)
{
BLAS_CHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ),
&lda, &beta, complex_ptr( c_ptr ), &ldc);
}
inline
- void herk( char uplo, char trans, const int& n, const int& k, const double& alpha,
- const complex_d* a_ptr, const int lda, const double& beta, complex_d* c_ptr,
- const int& ldc)
+ void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const double& alpha,
+ const complex_d* a_ptr, const integer_t lda, const double& beta, complex_d* c_ptr,
+ const integer_t& ldc)
{
BLAS_ZHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ),
&lda, &beta, complex_ptr( c_ptr ), &ldc);
@@ -105,33 +105,33 @@
// trsm
//
inline
- void trsm( char side, char uplo, char transa, char diag, int m, int n,
- float const& alpha, float const* a_ptr, int lda,
- float* b_ptr, int ldb )
+ void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,
+ float const& alpha, float const* a_ptr, integer_t lda,
+ float* b_ptr, integer_t ldb )
{
BLAS_STRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ;
}
inline
- void trsm( char side, char uplo, char transa, char diag, int m, int n,
- double const& alpha, double const* a_ptr, int lda,
- double* b_ptr, int ldb )
+ void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,
+ double const& alpha, double const* a_ptr, integer_t lda,
+ double* b_ptr, integer_t ldb )
{
BLAS_DTRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ;
}
inline
- void trsm( char side, char uplo, char transa, char diag, int m, int n,
- complex_f const& alpha, complex_f const* a_ptr, int lda,
- complex_f* b_ptr, int ldb )
+ void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,
+ complex_f const& alpha, complex_f const* a_ptr, integer_t lda,
+ complex_f* b_ptr, integer_t ldb )
{
BLAS_CTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ;
}
inline
- void trsm( char side, char uplo, char transa, char diag, int m, int n,
- complex_d const& alpha, complex_d const* a_ptr, int lda,
- complex_d* b_ptr, int ldb )
+ void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,
+ complex_d const& alpha, complex_d const* a_ptr, integer_t lda,
+ complex_d* b_ptr, integer_t ldb )
{
BLAS_ZTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ;
}
Modified: sandbox/boost/numeric/bindings/lapack/gbsv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gbsv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gbsv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -27,26 +27,26 @@
namespace detail {
inline
- void gbtrf (int const n, int const m, int const kl, int const ku,
- float* ab, int const ldab, int* ipiv, int* info)
+ void gbtrf (integer_t const n, integer_t const m, integer_t const kl, integer_t const ku,
+ float* ab, integer_t const ldab, integer_t* ipiv, integer_t* info)
{
LAPACK_SGBTRF (&n, &m, &kl, &ku, ab, &ldab, ipiv, info);
}
inline
- void gbtrf (int const n, int const m, int const kl, int const ku,
- double* ab, int const ldab, int* ipiv, int* info)
+ void gbtrf (integer_t const n, integer_t const m, integer_t const kl, integer_t const ku,
+ double* ab, integer_t const ldab, integer_t* ipiv, integer_t* info)
{
LAPACK_DGBTRF (&n, &m, &kl, &ku, ab, &ldab, ipiv, info);
}
inline
- void gbtrf (int const n, int const m, int const kl, int const ku,
- traits::complex_f* ab, int const ldab, int* ipiv, int* info)
+ void gbtrf (integer_t const n, integer_t const m, integer_t const kl, integer_t const ku,
+ traits::complex_f* ab, integer_t const ldab, integer_t* ipiv, integer_t* info)
{
LAPACK_CGBTRF (&n, &m, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv, info);
}
inline
- void gbtrf (int const n, int const m, int const kl, int const ku,
- traits::complex_d* ab, int const ldab, int* ipiv, int* info)
+ void gbtrf (integer_t const n, integer_t const m, integer_t const kl, integer_t const ku,
+ traits::complex_d* ab, integer_t const ldab, integer_t* ipiv, integer_t* info)
{
LAPACK_ZGBTRF (&n, &m, &kl, &ku, traits::complex_ptr(ab), &ldab, ipiv, info);
}
@@ -66,19 +66,19 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
- int const m = traits::matrix_size2 (a);
+ integer_t const n = traits::matrix_size1 (a);
+ integer_t const m = traits::matrix_size2 (a);
assert (traits::vector_size (ipiv) == (m < n ? m : n));
// if the matrix has kl lower and ku upper diagonals, then we should have
// allocated kl lower and kl+ku upper diagonals
- int const kl = traits::matrix_lower_bandwidth (a);
- int const ku = traits::matrix_upper_bandwidth (a) - kl;
- int const ld = traits::leading_dimension (a);
+ integer_t const kl = traits::matrix_lower_bandwidth (a);
+ integer_t const ku = traits::matrix_upper_bandwidth (a) - kl;
+ integer_t const ld = traits::leading_dimension (a);
assert(ku >= 0);
- int info;
+ integer_t info;
detail::gbtrf (n, m, kl, ku,
traits::matrix_storage (a),
ld,
@@ -90,30 +90,30 @@
namespace detail {
inline
- void gbtrs (char const trans, int const n, int const kl, int const ku, int const m,
- float const* ab, int const ldab, int const* ipiv,
- float* b, int const ldb, int* info)
+ void gbtrs (char const trans, integer_t const n, integer_t const kl, integer_t const ku, integer_t const m,
+ float const* ab, integer_t const ldab, integer_t const* ipiv,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SGBTRS (&trans, &n, &kl, &ku, &m, ab, &ldab, ipiv, b, &ldb, info);
}
inline
- void gbtrs (char const trans, int const n, int const kl, int const ku, int const m,
- double const* ab, int const ldab, int const* ipiv,
- double* b, int const ldb, int* info)
+ void gbtrs (char const trans, integer_t const n, integer_t const kl, integer_t const ku, integer_t const m,
+ double const* ab, integer_t const ldab, integer_t const* ipiv,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DGBTRS (&trans, &n, &kl, &ku, &m, ab, &ldab, ipiv, b, &ldb, info);
}
inline
- void gbtrs (char const trans, int const n, int const kl, int const ku, int const m,
- traits::complex_f const* ab, int const ldab, int const* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void gbtrs (char const trans, integer_t const n, integer_t const kl, integer_t const ku, integer_t const m,
+ traits::complex_f const* ab, integer_t const ldab, integer_t const* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CGBTRS (&trans, &n, &kl, &ku, &m, traits::complex_ptr(ab), &ldab, ipiv, traits::complex_ptr(b), &ldb, info);
}
inline
- void gbtrs (char const trans, int const n, int const kl, int const ku, int const m,
- traits::complex_d const* ab, int const ldab, int const* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void gbtrs (char const trans, integer_t const n, integer_t const kl, integer_t const ku, integer_t const m,
+ traits::complex_d const* ab, integer_t const ldab, integer_t const* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZGBTRS (&trans, &n, &kl, &ku, &m, traits::complex_ptr(ab), &ldab, ipiv, traits::complex_ptr(b), &ldb, info);
}
@@ -132,20 +132,20 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (ipiv));
// if the matrix has kl lower and ku upper diagonals, then we should have
// allocated kl lower and kl+ku upper diagonals
- int const kl = traits::matrix_lower_bandwidth (a);
- int const ku = traits::matrix_upper_bandwidth (a) - kl;
- int const ld = traits::leading_dimension (a);
+ integer_t const kl = traits::matrix_lower_bandwidth (a);
+ integer_t const ku = traits::matrix_upper_bandwidth (a) - kl;
+ integer_t const ld = traits::leading_dimension (a);
assert(ku >= 0);
- int info;
+ integer_t info;
detail::gbtrs (trans, n, kl, ku, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/gees.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gees.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gees.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -60,10 +60,10 @@
namespace detail {
inline
- void gees (char const jobvs, char const sort, logical_t* select, int const n,
- float* a, int const lda, int& sdim, traits::complex_f* w,
- float* vs, int const ldvs, float* work, int const lwork,
- bool* bwork, int& info)
+ void gees (char const jobvs, char const sort, logical_t* select, integer_t const n,
+ float* a, integer_t const lda, integer_t& sdim, traits::complex_f* w,
+ float* vs, integer_t const ldvs, float* work, integer_t const lwork,
+ bool* bwork, integer_t& info)
{
traits::detail::array<float> wr(n);
traits::detail::array<float> wi(n);
@@ -78,10 +78,10 @@
inline
- void gees (char const jobvs, char const sort, logical_t* select, int const n,
- double* a, int const lda, int& sdim, traits::complex_d* w,
- double* vs, int const ldvs, double* work, int const lwork,
- bool* bwork, int& info)
+ void gees (char const jobvs, char const sort, logical_t* select, integer_t const n,
+ double* a, integer_t const lda, integer_t& sdim, traits::complex_d* w,
+ double* vs, integer_t const ldvs, double* work, integer_t const lwork,
+ bool* bwork, integer_t& info)
{
traits::detail::array<double> wr(n);
traits::detail::array<double> wi(n);
@@ -96,11 +96,11 @@
inline
- void gees (char const jobvs, char const sort, logical_t* select, int const n,
- traits::complex_f* a, int const lda, int& sdim, traits::complex_f* w,
- traits::complex_f* vs, int const ldvs,
- traits::complex_f* work, int lwork, float* rwork, bool* bwork,
- int& info)
+ void gees (char const jobvs, char const sort, logical_t* select, integer_t const n,
+ traits::complex_f* a, integer_t const lda, integer_t& sdim, traits::complex_f* w,
+ traits::complex_f* vs, integer_t const ldvs,
+ traits::complex_f* work, integer_t lwork, float* rwork, bool* bwork,
+ integer_t& info)
{
LAPACK_CGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim,
traits::complex_ptr(w), traits::complex_ptr (vs), &ldvs,
@@ -109,11 +109,11 @@
inline
- void gees (char const jobvs, char const sort, logical_t* select, int const n,
- traits::complex_d* a, int const lda, int& sdim, traits::complex_d* w,
- traits::complex_d* vs, int const ldvs,
- traits::complex_d* work, int lwork, double* rwork, bool* bwork,
- int& info)
+ void gees (char const jobvs, char const sort, logical_t* select, integer_t const n,
+ traits::complex_d* a, integer_t const lda, integer_t& sdim, traits::complex_d* w,
+ traits::complex_d* vs, integer_t const ldvs,
+ traits::complex_d* work, integer_t lwork, double* rwork, bool* bwork,
+ integer_t& info)
{
LAPACK_ZGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim,
traits::complex_ptr(w), traits::complex_ptr(vs), &ldvs,
@@ -141,7 +141,7 @@
typedef typename MatrA::value_type value_type ;
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (vs));
assert (n == traits::matrix_size2 (vs));
@@ -151,7 +151,7 @@
logical_t* select=0;
bool* bwork=0;
- int info, sdim;
+ integer_t info, sdim;
detail::gees (jobvs, 'N', select, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -185,7 +185,7 @@
typedef typename MatrA::value_type value_type ;
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (vs));
assert (n == traits::matrix_size2 (vs));
@@ -196,7 +196,7 @@
logical_t* select=0;
bool* bwork=0;
- int info, sdim;
+ integer_t info, sdim;
detail::gees (jobvs, 'N', select, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -225,7 +225,7 @@
typedef typename MatrA::value_type value_type ;
typedef typename traits::type_traits< value_type >::real_type real_type ;
- int n = traits::matrix_size1( a );
+ integer_t n = traits::matrix_size1( a );
traits::detail::array<value_type> work( 2*n );
traits::detail::array<real_type> rwork( n );
@@ -238,7 +238,7 @@
typedef typename MatrA::value_type value_type ;
typedef typename traits::type_traits< value_type >::real_type real_type ;
- int n = traits::matrix_size1( a );
+ integer_t n = traits::matrix_size1( a );
traits::detail::array<value_type> work( 2*n );
traits::detail::array<real_type> rwork( n );
@@ -261,7 +261,7 @@
typedef typename MatrA::value_type value_type ;
typedef typename traits::type_traits< value_type >::real_type real_type ;
- int n = traits::matrix_size1( a );
+ integer_t n = traits::matrix_size1( a );
traits::detail::array<value_type> work( 3*n );
@@ -273,7 +273,7 @@
typedef typename MatrA::value_type value_type ;
typedef typename traits::type_traits< value_type >::real_type real_type ;
- int n = traits::matrix_size1( a );
+ integer_t n = traits::matrix_size1( a );
traits::detail::array<value_type> work( 3*n );
Modified: sandbox/boost/numeric/bindings/lapack/geev.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/geev.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/geev.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -72,32 +72,32 @@
namespace detail {
inline
- int geev_backend(const char* jobvl, const char* jobvr, const int* n, float* a,
- const int* lda, float* wr, float* wi, float* vl, const int* ldvl,
- float* vr, const int* ldvr, float* work, const int* lwork)
+ int geev_backend(const char* jobvl, const char* jobvr, const integer_t* n, float* a,
+ const integer_t* lda, float* wr, float* wi, float* vl, const integer_t* ldvl,
+ float* vr, const integer_t* ldvr, float* work, const integer_t* lwork)
{
- int info;
+ integer_t info;
LAPACK_SGEEV(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, &info);
return info;
}
inline
- int geev_backend(const char* jobvl, const char* jobvr, const int* n, double* a,
- const int* lda, double* wr, double* wi, double* vl, const int* ldvl,
- double* vr, const int* ldvr, double* work, const int* lwork)
+ int geev_backend(const char* jobvl, const char* jobvr, const integer_t* n, double* a,
+ const integer_t* lda, double* wr, double* wi, double* vl, const integer_t* ldvl,
+ double* vr, const integer_t* ldvr, double* work, const integer_t* lwork)
{
- int info;
+ integer_t info;
LAPACK_DGEEV(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, &info);
return info;
}
inline
- int geev_backend(const char* jobvl, const char* jobvr, const int* n, traits::complex_f* a,
- const int* lda, traits::complex_f* w, traits::complex_f* vl, const int* ldvl,
- traits::complex_f* vr, const int* ldvr, traits::complex_f* work, const int* lwork,
+ int geev_backend(const char* jobvl, const char* jobvr, const integer_t* n, traits::complex_f* a,
+ const integer_t* lda, traits::complex_f* w, traits::complex_f* vl, const integer_t* ldvl,
+ traits::complex_f* vr, const integer_t* ldvr, traits::complex_f* work, const integer_t* lwork,
float* rwork)
{
- int info;
+ integer_t info;
LAPACK_CGEEV(jobvl, jobvr, n,
traits::complex_ptr(a), lda,
traits::complex_ptr(w),
@@ -109,12 +109,12 @@
}
inline
- int geev_backend(const char* jobvl, const char* jobvr, const int* n, traits::complex_d* a,
- const int* lda, traits::complex_d* w, traits::complex_d* vl, const int* ldvl,
- traits::complex_d* vr, const int* ldvr, traits::complex_d* work, const int* lwork,
+ int geev_backend(const char* jobvl, const char* jobvr, const integer_t* n, traits::complex_d* a,
+ const integer_t* lda, traits::complex_d* w, traits::complex_d* vl, const integer_t* ldvl,
+ traits::complex_d* vr, const integer_t* ldvr, traits::complex_d* work, const integer_t* lwork,
double* rwork)
{
- int info;
+ integer_t info;
LAPACK_ZGEEV(jobvl, jobvr, n,
traits::complex_ptr(a), lda,
traits::complex_ptr(w),
@@ -138,7 +138,7 @@
int geev(real_case, const char jobvl, const char jobvr, A& a, W& w,
V* vl, V *vr)
{
- int const n = traits::matrix_size1(a);
+ integer_t const n = traits::matrix_size1(a);
typedef typename A::value_type value_type;
traits::detail::array<value_type> wr(n);
traits::detail::array<value_type> wi(n);
@@ -146,13 +146,13 @@
traits::detail::array<value_type> vl2(vl ? 0 : n);
traits::detail::array<value_type> vr2(vr ? 0 : n);
value_type* vl_real = vl ? traits::matrix_storage(*vl) : vl2.storage();
- const int ldvl = vl ? traits::matrix_size2(*vl) : 1;
+ const integer_t ldvl = vl ? traits::matrix_size2(*vl) : 1;
value_type* vr_real = vr ? traits::matrix_storage(*vr) : vr2.storage();
- const int ldvr = vr ? traits::matrix_size2(*vr) : 1;
+ const integer_t ldvr = vr ? traits::matrix_size2(*vr) : 1;
// workspace query
- int lwork = -1;
+ integer_t lwork = -1;
value_type work_temp;
int result = geev_backend(&jobvl, &jobvr, &n,
traits::matrix_storage(a), &n,
@@ -162,7 +162,7 @@
if (result != 0)
return result;
- lwork = (int) work_temp;
+ lwork = traits::detail::to_int(work_temp);
traits::detail::array<value_type> work(lwork);
result = geev_backend(&jobvl, &jobvr, &n,
traits::matrix_storage(a), &n,
@@ -182,18 +182,18 @@
int geev(mixed_case, const char jobvl, const char jobvr, A& a, W& w,
V* vl, V *vr)
{
- int const n = traits::matrix_size1(a);
+ integer_t const n = traits::matrix_size1(a);
typedef typename A::value_type value_type;
traits::detail::array<value_type> wr(n);
traits::detail::array<value_type> wi(n);
traits::detail::array<value_type> vl2(vl ? n*n : n);
traits::detail::array<value_type> vr2(vr ? n*n : n);
- const int ldvl2 = vl ? n : 1;
- const int ldvr2 = vr ? n : 1;
+ const integer_t ldvl2 = vl ? n : 1;
+ const integer_t ldvr2 = vr ? n : 1;
// workspace query
- int lwork = -1;
+ integer_t lwork = -1;
value_type work_temp;
int result = geev_backend(&jobvl, &jobvr, &n,
traits::matrix_storage(a), &n,
@@ -203,7 +203,7 @@
if (result != 0)
return result;
- lwork = (int) work_temp;
+ lwork = traits::detail::to_int(work_temp);
traits::detail::array<value_type> work(lwork);
result = geev_backend(&jobvl, &jobvr, &n,
traits::matrix_storage(a), &n,
@@ -214,7 +214,7 @@
typedef typename V::value_type vec_value_type;
vec_value_type* vl_stor = NULL;
vec_value_type* vr_stor = NULL;
- int ldvl = 0, ldvr = 0;
+ integer_t ldvl = 0, ldvr = 0;
if (vl)
{
vl_stor = traits::matrix_storage(*vl);
@@ -227,7 +227,7 @@
}
typedef std::complex<value_type> cmplx_t;
- for (int i = 0; i < n; i++)
+ for (std::ptrdiff_t i = 0; i < n; i++)
{
traits::vector_storage(w)[i] = cmplx_t(wr[i], wi[i]);
if (wi[i] != 0)
@@ -237,7 +237,7 @@
assert(wi[i+1] == -wi[i]);
traits::vector_storage(w)[i+1] = cmplx_t(wr[i+1], wi[i+1]);
- for (int j = 0; j < n; j++)
+ for (std::ptrdiff_t j = 0; j < n; j++)
{
if (vl)
{
@@ -255,7 +255,7 @@
}
else
{
- for (int j = 0; j < n; j++)
+ for (std::ptrdiff_t j = 0; j < n; j++)
{
if (vl)
vl_stor[i*ldvl+j] = vl2[i*n+j];
@@ -275,18 +275,18 @@
typedef typename A::value_type value_type;
typedef typename traits::type_traits<value_type>::real_type real_type;
- int const n = traits::matrix_size1(a);
+ integer_t const n = traits::matrix_size1(a);
traits::detail::array<real_type> rwork(2*n);
traits::detail::array<value_type> vl2(vl ? 0 : n);
traits::detail::array<value_type> vr2(vr ? 0 : n);
value_type* vl_real = vl ? traits::matrix_storage(*vl) : vl2.storage();
- const int ldvl = vl ? traits::matrix_size2(*vl) : 1;
+ const integer_t ldvl = vl ? traits::matrix_size2(*vl) : 1;
value_type* vr_real = vr ? traits::matrix_storage(*vr) : vr2.storage();
- const int ldvr = vr ? traits::matrix_size2(*vr) : 1;
+ const integer_t ldvr = vr ? traits::matrix_size2(*vr) : 1;
// workspace query
- int lwork = -1;
+ integer_t lwork = -1;
value_type work_temp;
int result = geev_backend(&jobvl, &jobvr, &n,
traits::matrix_storage(a), &n,
@@ -296,7 +296,7 @@
if (result != 0)
return result;
- lwork = (int) std::real(work_temp);
+ lwork = traits::detail::to_int(work_temp);
traits::detail::array<value_type> work(lwork);
result = geev_backend(&jobvl, &jobvr, &n,
traits::matrix_storage(a), &n,
@@ -324,7 +324,7 @@
#endif
#ifndef NDEBUG
- int const n = traits::matrix_size1(a);
+ std::ptrdiff_t const n = traits::matrix_size1(a);
#endif
assert(traits::matrix_size2(a)==n);
Modified: sandbox/boost/numeric/bindings/lapack/gels.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gels.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gels.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -69,26 +69,26 @@
namespace detail {
- inline void gels(char const trans, const int m, const int n,
- const int nrhs, float *a, const int lda,
- float *b, const int ldb, float *work,
- const int lwork, int *info)
+ inline void gels(char const trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, float *a, const integer_t lda,
+ float *b, const integer_t ldb, float *work,
+ const integer_t lwork, integer_t *info)
{
LAPACK_SGELS(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info);
}
- inline void gels(char const trans, const int m, const int n,
- const int nrhs, double *a, const int lda,
- double *b, const int ldb, double *work,
- const int lwork, int *info)
+ inline void gels(char const trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, double *a, const integer_t lda,
+ double *b, const integer_t ldb, double *work,
+ const integer_t lwork, integer_t *info)
{
LAPACK_DGELS(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info);
}
- inline void gels(char const trans, const int m, const int n,
- const int nrhs, traits::complex_f *a, const int lda,
- traits::complex_f *b, const int ldb, traits::complex_f *work,
- const int lwork, int *info)
+ inline void gels(char const trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, traits::complex_f *a, const integer_t lda,
+ traits::complex_f *b, const integer_t ldb, traits::complex_f *work,
+ const integer_t lwork, integer_t *info)
{
LAPACK_CGELS(&trans, &m, &n, &nrhs,
traits::complex_ptr(a), &lda,
@@ -96,10 +96,10 @@
traits::complex_ptr(work), &lwork, info);
}
- inline void gels(char const trans, const int m, const int n,
- const int nrhs, traits::complex_d *a, const int lda,
- traits::complex_d *b, const int ldb, traits::complex_d *work,
- const int lwork, int *info)
+ inline void gels(char const trans, const integer_t m, const integer_t n,
+ const integer_t nrhs, traits::complex_d *a, const integer_t lda,
+ traits::complex_d *b, const integer_t ldb, traits::complex_d *work,
+ const integer_t lwork, integer_t *info)
{
LAPACK_ZGELS(&trans, &m, &n, &nrhs,
traits::complex_ptr(a), &lda,
@@ -111,10 +111,12 @@
template <typename MatrA, typename VecB, typename Work>
int gels(const char trans, MatrA& A, VecB& b, Work& work)
{
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int mrhs = traits::matrix_size1(b);
- const int nrhs = traits::matrix_size2(b);
+#ifndef NDEBUG
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t mrhs = traits::matrix_size1(b);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(b);
+#endif
// sanity checks
assert(trans == 'N' || trans == 'T' || trans == 'C');
@@ -123,7 +125,7 @@
assert(traits::leading_dimension(A) >= 1 && traits::leading_dimension(b) >= 1);
assert(mrhs == std::max(m, n));
- int info;
+ integer_t info;
detail::gels(trans,
traits::matrix_size1(A),
traits::matrix_size2(A),
@@ -141,10 +143,10 @@
// query for recommended workspace
template <typename MatrA, typename VecB>
- int gels_optimal_work(const char trans, MatrA& A, VecB& b)
+ integer_t gels_optimal_work(const char trans, MatrA& A, VecB& b)
{
typename MatrA::value_type work;
- int info;
+ integer_t info;
detail::gels(trans,
traits::matrix_size1(A),
traits::matrix_size2(A),
@@ -159,7 +161,7 @@
assert(info == 0);
- int lwork = traits::detail::to_int(work);
+ integer_t lwork = traits::detail::to_int(work);
return lwork;
}
@@ -170,7 +172,7 @@
int gels(const char trans, MatrA& A, VecB& b, optimal_workspace)
{
// query optimal workspace size
- int work_size = detail::gels_optimal_work(trans, A, b);
+ integer_t work_size = detail::gels_optimal_work(trans, A, b);
traits::detail::array<typename MatrA::value_type> work(work_size);
return detail::gels(trans, A, b, work);
@@ -179,15 +181,15 @@
template <typename MatrA, typename VecB>
int gels(const char trans, MatrA& A, VecB& b, minimal_workspace)
{
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int r = traits::matrix_size2(b);
-
- const int minmn = std::min(m, n); //m < n ? m : n;
- const int maxmn = std::max(m, n); // m > n ? m : n;
- const int maxdim = std::max(maxmn, r); // maxmn > r ? maxmn : r;
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t r = traits::matrix_size2(b);
+
+ const std::ptrdiff_t minmn = std::min(m, n); //m < n ? m : n;
+ const std::ptrdiff_t maxmn = std::max(m, n); // m > n ? m : n;
+ const std::ptrdiff_t maxdim = std::max(maxmn, r); // maxmn > r ? maxmn : r;
- traits::detail::array<typename MatrA::value_type> work(minmn + std::max(1, maxdim));
+ traits::detail::array<typename MatrA::value_type> work(minmn + std::max<std::ptrdiff_t>(1, maxdim));
return detail::gels(trans, A, b, work);
}
Modified: sandbox/boost/numeric/bindings/lapack/gelsd.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gelsd.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gelsd.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -32,29 +32,29 @@
namespace detail {
- inline void gelsd(const int m, const int n, const int nrhs,
- float *a, const int lda, float *b, const int ldb,
- float *s, const float rcond, int *rank, float *work,
- const int lwork, int *iwork, int *info)
+ inline void gelsd(const integer_t m, const integer_t n, const integer_t nrhs,
+ float *a, const integer_t lda, float *b, const integer_t ldb,
+ float *s, const float rcond, integer_t *rank, float *work,
+ const integer_t lwork, integer_t *iwork, integer_t *info)
{
LAPACK_SGELSD(&m, &n, &nrhs, a, &lda, b, &ldb, s,
&rcond, rank, work, &lwork, iwork, info);
}
- inline void gelsd(const int m, const int n, const int nrhs,
- double *a, const int lda, double *b, const int ldb,
- double *s, const double rcond, int *rank, double *work,
- const int lwork, int *iwork, int *info)
+ inline void gelsd(const integer_t m, const integer_t n, const integer_t nrhs,
+ double *a, const integer_t lda, double *b, const integer_t ldb,
+ double *s, const double rcond, integer_t *rank, double *work,
+ const integer_t lwork, integer_t *iwork, integer_t *info)
{
LAPACK_DGELSD(&m, &n, &nrhs, a, &lda, b, &ldb, s,
&rcond, rank, work, &lwork, iwork, info);
}
- inline void gelsd(const int m, const int n, const int nrhs,
- traits::complex_f *a, const int lda, traits::complex_f *b,
- const int ldb, float *s, const float rcond, int *rank,
- traits::complex_f *work, const int lwork, float *rwork,
- int *iwork, int *info)
+ inline void gelsd(const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_f *a, const integer_t lda, traits::complex_f *b,
+ const integer_t ldb, float *s, const float rcond, integer_t *rank,
+ traits::complex_f *work, const integer_t lwork, float *rwork,
+ integer_t *iwork, integer_t *info)
{
LAPACK_CGELSD(&m, &n, &nrhs, traits::complex_ptr(a),
&lda, traits::complex_ptr(b), &ldb, s,
@@ -62,11 +62,11 @@
&lwork, rwork, iwork, info);
}
- inline void gelsd(const int m, const int n, const int nrhs,
- traits::complex_d *a, const int lda, traits::complex_d *b,
- const int ldb, double *s, const double rcond, int *rank,
- traits::complex_d *work, const int lwork, double *rwork,
- int *iwork, int *info)
+ inline void gelsd(const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_d *a, const integer_t lda, traits::complex_d *b,
+ const integer_t ldb, double *s, const double rcond, integer_t *rank,
+ traits::complex_d *work, const integer_t lwork, double *rwork,
+ integer_t *iwork, integer_t *info)
{
LAPACK_ZGELSD(&m, &n, &nrhs, traits::complex_ptr(a),
&lda, traits::complex_ptr(b), &ldb, s,
@@ -81,29 +81,29 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
- const int maxmn = std::max(m, n);
- const int minmn = std::min(m, n);
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+ const std::ptrdiff_t maxmn = std::max(m, n);
+ const std::ptrdiff_t minmn = std::min(m, n);
// sanity checks
assert(m >= 0 && n >= 0);
assert(nrhs >= 0);
- assert(traits::leading_dimension(A) >= std::max(1, m));
- assert(traits::leading_dimension(B) >= std::max(1, maxmn));
+ assert(traits::leading_dimension(A) >= std::max<std::ptrdiff_t>(1, m));
+ assert(traits::leading_dimension(B) >= std::max<std::ptrdiff_t>(1, maxmn));
assert(traits::vector_size(work) >= 1);
- assert(traits::vector_size(s) >= std::max(1, minmn));
+ assert(traits::vector_size(s) >= std::max<std::ptrdiff_t>(1, minmn));
- int info;
+ integer_t info;
const real_t rcond = -1; // use machine precision
- int rank;
+ integer_t rank;
// query for maximum size of subproblems
- const int smlsiz = ilaenv(9, "GELSD", "");
- const int nlvl = static_cast<int>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
+ const integer_t smlsiz = ilaenv(9, "GELSD", "");
+ const integer_t nlvl = static_cast<integer_t>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
- traits::detail::array<int> iwork(3*minmn*nlvl + 11*minmn);
+ traits::detail::array<integer_t> iwork(3*minmn*nlvl + 11*minmn);
detail::gelsd(traits::matrix_size1(A),
traits::matrix_size2(A),
@@ -131,29 +131,29 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
- const int maxmn = std::max(m, n);
- const int minmn = std::min(m, n);
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+ const std::ptrdiff_t maxmn = std::max(m, n);
+ const std::ptrdiff_t minmn = std::min(m, n);
// sanity checks
assert(m >= 0 && n >= 0);
assert(nrhs >= 0);
- assert(traits::leading_dimension(A) >= std::max(1, m));
- assert(traits::leading_dimension(B) >= std::max(1, maxmn));
+ assert(traits::leading_dimension(A) >= std::max<std::ptrdiff_t>(1, m));
+ assert(traits::leading_dimension(B) >= std::max<std::ptrdiff_t>(1, maxmn));
assert(traits::vector_size(work) >= 1);
- assert(traits::vector_size(s) >= std::max(1, minmn));
+ assert(traits::vector_size(s) >= std::max<std::ptrdiff_t>(1, minmn));
- int info;
+ integer_t info;
const real_t rcond = -1; // use machine precision
- int rank;
+ integer_t rank;
// query for maximum size of subproblems
- const int smlsiz = ilaenv(9, "GELSD", "");
- const int nlvl = static_cast<int>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
+ const integer_t smlsiz = ilaenv(9, "GELSD", "");
+ const integer_t nlvl = static_cast<integer_t>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
- traits::detail::array<int> iwork(3*minmn*nlvl + 11*minmn);
+ traits::detail::array<integer_t> iwork(3*minmn*nlvl + 11*minmn);
detail::gelsd(traits::matrix_size1(A),
traits::matrix_size2(A),
@@ -186,19 +186,19 @@
{
typedef typename MatrA::value_type val_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
-
- const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+
+ const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
// query for maximum size of subproblems
- const int smlsiz = ilaenv(9, "GELSD", "");
- const int nlvl = static_cast<int>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
+ const integer_t smlsiz = ilaenv(9, "GELSD", "");
+ const integer_t nlvl = static_cast<integer_t>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
- const int lwork = 12*minmn + 2*minmn*smlsiz + 8*minmn*nlvl +
+ const integer_t lwork = 12*minmn + 2*minmn*smlsiz + 8*minmn*nlvl +
minmn*nrhs + (smlsiz+1)*(smlsiz+1);
traits::detail::array<val_t> work(lwork);
@@ -212,20 +212,20 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- //const int m = traits::matrix_size1(A);
- //const int n = traits::matrix_size2(A);
- //const int nrhs = traits::matrix_size2(B);
-
- //const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
+ //const std::ptrdiff_t m = traits::matrix_size1(A);
+ //const std::ptrdiff_t n = traits::matrix_size2(A);
+ //const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+
+ //const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
val_t temp_work;
- int temp_iwork;
+ integer_t temp_iwork;
const real_t rcond = -1;
- int rank;
- int info;
+ integer_t rank;
+ integer_t info;
// query for optimal workspace size
detail::gelsd(traits::matrix_size1(A),
@@ -245,7 +245,7 @@
assert(info == 0);
- const int lwork = traits::detail::to_int(temp_work);
+ const integer_t lwork = traits::detail::to_int(temp_work);
traits::detail::array<val_t> work(lwork);
@@ -255,13 +255,13 @@
template <typename MatrA, typename MatrB, typename VecS, typename Work>
int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace1<Work> workspace) const
{
- //const int m = traits::matrix_size1(A);
- //const int n = traits::matrix_size2(A);
- //const int nrhs = traits::matrix_size2(B);
-
- //const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
+ //const std::ptrdiff_t m = traits::matrix_size1(A);
+ //const std::ptrdiff_t n = traits::matrix_size2(A);
+ //const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+
+ //const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
return gelsd(A, B, s, workspace.w_);
}
@@ -277,24 +277,24 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
-
- const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+
+ const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
// query for maximum size of subproblems
- const int smlsiz = ilaenv(9, "GELSD", "");
- const int nlvl = static_cast<int>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
+ const integer_t smlsiz = ilaenv(9, "GELSD", "");
+ const integer_t nlvl = static_cast<integer_t>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
traits::detail::array<val_t> work(2*minmn + minmn*nrhs);
- const int rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl +
+ const std::ptrdiff_t rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl +
3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1);
- traits::detail::array<real_t> rwork(std::max(1, rwork_size));
+ traits::detail::array<real_t> rwork(std::max<std::ptrdiff_t>(1, rwork_size));
return gelsd(A, B, s, work, rwork);
}
@@ -305,21 +305,21 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
-
- const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+
+ const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
val_t temp_work;
real_t temp_rwork;
- int temp_iwork;
+ integer_t temp_iwork;
const real_t rcond = -1;
- int rank;
- int info;
+ integer_t rank;
+ integer_t info;
// query for optimal workspace size
detail::gelsd(traits::matrix_size1(A),
@@ -340,18 +340,18 @@
assert(info == 0);
- const int lwork = traits::detail::to_int(temp_work);
+ const integer_t lwork = traits::detail::to_int(temp_work);
traits::detail::array<val_t> work(lwork);
// query for maximum size of subproblems
- const int smlsiz = ilaenv(9, "GELSD", "");
- const int nlvl = static_cast<int>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
+ const integer_t smlsiz = ilaenv(9, "GELSD", "");
+ const integer_t nlvl = static_cast<integer_t>(((std::log(static_cast<float>(minmn))/std::log(2.f))/ (smlsiz+1)) + 1);
- const int rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl +
+ const std::ptrdiff_t rwork_size = 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl +
3*smlsiz*nrhs + (smlsiz+1)*(smlsiz+1);
- traits::detail::array<real_t> rwork(std::max(1, rwork_size));
+ traits::detail::array<real_t> rwork(std::max<std::ptrdiff_t>(1, rwork_size));
return gelsd(A, B, s, work, rwork);
}
@@ -359,13 +359,13 @@
template <typename MatrA, typename MatrB, typename VecS, typename Work, typename RWork>
int operator() (MatrA& A, MatrB& B, VecS& s, detail::workspace2<Work, RWork> workspace) const
{
- //const int m = traits::matrix_size1(A);
- //const int n = traits::matrix_size2(A);
- //const int nrhs = traits::matrix_size2(B);
-
- //const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
+ //const std::ptrdiff_t m = traits::matrix_size1(A);
+ //const std::ptrdiff_t n = traits::matrix_size2(A);
+ //const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+
+ //const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, nrhs); // maxmnr = maxmn > nrhs ? maxmn : nrhs
return gelsd(A, B, s, workspace.w_, workspace.wr_);
}
@@ -400,10 +400,10 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
- const int s_size = std::max(1, std::min(m,n));
+ const std::ptrdiff_t s_size = std::max<std::ptrdiff_t>(1, std::min(m,n));
traits::detail::array<real_t> s(s_size);
return detail::Gelsd<n_workspace_args<val_t>::value>() (A, B, s, workspace);
Modified: sandbox/boost/numeric/bindings/lapack/gelss.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gelss.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gelss.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -31,26 +31,26 @@
namespace detail {
- inline void gelss(const int m, const int n, const int nrhs,
- float *a, const int lda, float *b, const int ldb,
- float *s, const float rcond, int *rank, float *work,
- const int lwork, int *info)
+ inline void gelss(const integer_t m, const integer_t n, const integer_t nrhs,
+ float *a, const integer_t lda, float *b, const integer_t ldb,
+ float *s, const float rcond, integer_t *rank, float *work,
+ const integer_t lwork, integer_t *info)
{
LAPACK_SGELSS(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info);
}
- inline void gelss(const int m, const int n, const int nrhs,
- double *a, const int lda, double *b, const int ldb,
- double *s, const double rcond, int *rank, double *work,
- const int lwork, int *info)
+ inline void gelss(const integer_t m, const integer_t n, const integer_t nrhs,
+ double *a, const integer_t lda, double *b, const integer_t ldb,
+ double *s, const double rcond, integer_t *rank, double *work,
+ const integer_t lwork, integer_t *info)
{
LAPACK_DGELSS(&m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info);
}
- inline void gelss(const int m, const int n, const int nrhs,
- traits::complex_f *a, const int lda, traits::complex_f *b,
- const int ldb, float *s, const float rcond, int *rank,
- traits::complex_f *work, const int lwork, float *rwork, int *info)
+ inline void gelss(const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_f *a, const integer_t lda, traits::complex_f *b,
+ const integer_t ldb, float *s, const float rcond, integer_t *rank,
+ traits::complex_f *work, const integer_t lwork, float *rwork, integer_t *info)
{
LAPACK_CGELSS(&m, &n, &nrhs, traits::complex_ptr(a),
&lda, traits::complex_ptr(b), &ldb, s,
@@ -58,10 +58,10 @@
&lwork, rwork, info);
}
- inline void gelss(const int m, const int n, const int nrhs,
- traits::complex_d *a, const int lda, traits::complex_d *b,
- const int ldb, double *s, const double rcond, int *rank,
- traits::complex_d *work, const int lwork, double *rwork, int *info)
+ inline void gelss(const integer_t m, const integer_t n, const integer_t nrhs,
+ traits::complex_d *a, const integer_t lda, traits::complex_d *b,
+ const integer_t ldb, double *s, const double rcond, integer_t *rank,
+ traits::complex_d *work, const integer_t lwork, double *rwork, integer_t *info)
{
LAPACK_ZGELSS(&m, &n, &nrhs, traits::complex_ptr(a),
&lda, traits::complex_ptr(b), &ldb, s,
@@ -76,23 +76,23 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
- const int maxmn = std::max(m, n);
- const int minmn = std::min(m, n);
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+ const std::ptrdiff_t maxmn = std::max(m, n);
+ const std::ptrdiff_t minmn = std::min(m, n);
// sanity checks
assert(m >= 0 && n >= 0);
assert(nrhs >= 0);
- assert(traits::leading_dimension(A) >= std::max(1, m));
- assert(traits::leading_dimension(B) >= std::max(1, maxmn));
+ assert(traits::leading_dimension(A) >= std::max<std::ptrdiff_t>(1, m));
+ assert(traits::leading_dimension(B) >= std::max<std::ptrdiff_t>(1, maxmn));
assert(traits::vector_size(work) >= 1);
- assert(traits::vector_size(s) >= std::max(1, minmn));
+ assert(traits::vector_size(s) >= std::max<std::ptrdiff_t>(1, minmn));
- int info;
+ integer_t info;
const real_t rcond = -1; // use machine precision
- int rank;
+ integer_t rank;
detail::gelss(traits::matrix_size1(A),
traits::matrix_size2(A),
@@ -118,23 +118,23 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int nrhs = traits::matrix_size2(B);
- const int maxmn = std::max(m, n);
- const int minmn = std::min(m, n);
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t nrhs = traits::matrix_size2(B);
+ const std::ptrdiff_t maxmn = std::max(m, n);
+ const std::ptrdiff_t minmn = std::min(m, n);
// sanity checks
assert(m >= 0 && n >= 0);
assert(nrhs >= 0);
- assert(traits::leading_dimension(A) >= std::max(1, m));
- assert(traits::leading_dimension(B) >= std::max(1, maxmn));
+ assert(traits::leading_dimension(A) >= std::max<std::ptrdiff_t>(1, m));
+ assert(traits::leading_dimension(B) >= std::max<std::ptrdiff_t>(1, maxmn));
assert(traits::vector_size(work) >= 1);
- assert(traits::vector_size(s) >= std::max(1, minmn));
+ assert(traits::vector_size(s) >= std::max<std::ptrdiff_t>(1, minmn));
- int info;
+ integer_t info;
const real_t rcond = -1; // use machine precision
- int rank;
+ integer_t rank;
detail::gelss(traits::matrix_size1(A),
traits::matrix_size2(A),
@@ -167,13 +167,13 @@
{
typedef typename MatrA::value_type val_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int rhs = traits::matrix_size2(B);
-
- const int minmn = std::min(m, n); // minmn = m < n ? m : n
- const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t rhs = traits::matrix_size2(B);
+
+ const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ const std::ptrdiff_t maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
traits::detail::array<val_t> work(3*minmn + std::max(2*minmn, maxmnr));
@@ -186,19 +186,19 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- //const int m = traits::matrix_size1(A);
- //const int n = traits::matrix_size2(A);
- //const int rhs = traits::matrix_size2(B);
-
- //const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
+ //const std::ptrdiff_t m = traits::matrix_size1(A);
+ //const std::ptrdiff_t n = traits::matrix_size2(A);
+ //const std::ptrdiff_t rhs = traits::matrix_size2(B);
+
+ //const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
val_t temp_work;
const real_t rcond = -1;
- int rank;
- int info;
+ integer_t rank;
+ integer_t info;
// query for optimal workspace size
detail::gelss(traits::matrix_size1(A),
@@ -217,7 +217,7 @@
assert(info == 0);
- const int lwork = traits::detail::to_int(temp_work);
+ const integer_t lwork = traits::detail::to_int(temp_work);
traits::detail::array<val_t> work(lwork);
@@ -241,16 +241,16 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- const int rhs = traits::matrix_size2(B);
-
- const int minmn = std::min(m, n); // minmn = m < n ? m : n
- const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ const std::ptrdiff_t rhs = traits::matrix_size2(B);
+
+ const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ const std::ptrdiff_t maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
traits::detail::array<val_t> work(2*minmn + maxmnr);
- traits::detail::array<real_t> rwork(std::max(1, (5*minmn)));
+ traits::detail::array<real_t> rwork(std::max<std::ptrdiff_t>(1, (5*minmn)));
return gelss(A, B, s, work, rwork);
}
@@ -261,20 +261,20 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
- //const int rhs = traits::matrix_size2(B);
-
- const int minmn = std::min(m, n); // minmn = m < n ? m : n
- //const int maxmn = std::max(m, n); // maxmn = m > n ? m : n
- //const int maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
+ //const std::ptrdiff_t rhs = traits::matrix_size2(B);
+
+ const std::ptrdiff_t minmn = std::min(m, n); // minmn = m < n ? m : n
+ //const std::ptrdiff_t maxmn = std::max(m, n); // maxmn = m > n ? m : n
+ //const std::ptrdiff_t maxmnr = std::max(maxmn, rhs); // maxmnr = maxmn > rhs ? maxmn : rhs
val_t temp_work;
real_t temp_rwork;
const real_t rcond = -1;
- int rank;
- int info;
+ integer_t rank;
+ integer_t info;
// query for optimal workspace size
detail::gelss(traits::matrix_size1(A),
@@ -294,10 +294,10 @@
assert(info == 0);
- const int lwork = traits::detail::to_int(temp_work);
+ const integer_t lwork = traits::detail::to_int(temp_work);
traits::detail::array<val_t> work(lwork);
- traits::detail::array<real_t> rwork(std::max(1, (5*minmn)));
+ traits::detail::array<real_t> rwork(std::max<std::ptrdiff_t>(1, (5*minmn)));
return gelss(A, B, s, work, rwork);
}
@@ -338,10 +338,10 @@
typedef typename MatrA::value_type val_t;
typedef typename traits::type_traits<val_t>::real_type real_t;
- const int m = traits::matrix_size1(A);
- const int n = traits::matrix_size2(A);
+ const std::ptrdiff_t m = traits::matrix_size1(A);
+ const std::ptrdiff_t n = traits::matrix_size2(A);
- const int s_size = std::max(1, std::min(m,n));
+ const std::ptrdiff_t s_size = std::max<std::ptrdiff_t>(1, std::min(m,n));
traits::detail::array<real_t> s(s_size);
return detail::Gelss<n_workspace_args<val_t>::value>() (A, B, s, workspace);
Modified: sandbox/boost/numeric/bindings/lapack/geqrf.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/geqrf.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/geqrf.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -53,26 +53,26 @@
namespace detail {
inline
- void geqrf (int const m, int const n,
- float* a, int const lda,
- float* tau, float* work, int const lwork, int& info)
+ void geqrf (integer_t const m, integer_t const n,
+ float* a, integer_t const lda,
+ float* tau, float* work, integer_t const lwork, integer_t& info)
{
LAPACK_SGEQRF (&m, &n, a, &lda, tau, work, &lwork, &info);
}
inline
- void geqrf (int const m, int const n,
- double* a, int const lda,
- double* tau, double* work, int const lwork, int& info)
+ void geqrf (integer_t const m, integer_t const n,
+ double* a, integer_t const lda,
+ double* tau, double* work, integer_t const lwork, integer_t& info)
{
LAPACK_DGEQRF (&m, &n, a, &lda, tau, work, &lwork, &info);
}
inline
- void geqrf (int const m, int const n,
- traits::complex_f* a, int const lda,
+ void geqrf (integer_t const m, integer_t const n,
+ traits::complex_f* a, integer_t const lda,
traits::complex_f* tau, traits::complex_f* work,
- int const lwork, int& info)
+ integer_t const lwork, integer_t& info)
{
LAPACK_CGEQRF (&m, &n,
traits::complex_ptr (a), &lda,
@@ -82,10 +82,10 @@
inline
- void geqrf (int const m, int const n,
- traits::complex_d* a, int const lda,
+ void geqrf (integer_t const m, integer_t const n,
+ traits::complex_d* a, integer_t const lda,
traits::complex_d* tau, traits::complex_d* work,
- int const lwork, int& info)
+ integer_t const lwork, integer_t& info)
{
LAPACK_ZGEQRF (&m, &n,
traits::complex_ptr (a), &lda,
@@ -105,12 +105,12 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
- assert (std::min<int>(m,n) <= traits::vector_size (tau));
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
+ assert (std::min<integer_t>(m,n) <= traits::vector_size (tau));
assert (n <= traits::vector_size (work));
- int info;
+ integer_t info;
detail::geqrf (m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -127,8 +127,8 @@
template <typename A, typename Tau>
int geqrf (A& a, Tau& tau, optimal_workspace ) {
typedef typename A::value_type value_type ;
- const int n = traits::matrix_size2 (a);
- traits::detail::array<value_type> work(std::max<int>(1, n*32));
+ const std::ptrdiff_t n = traits::matrix_size2 (a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1, n*32));
return geqrf( a, tau, work );
}
@@ -138,8 +138,8 @@
template <typename A, typename Tau>
int geqrf (A& a, Tau& tau, minimal_workspace ) {
typedef typename A::value_type value_type ;
- const int n = traits::matrix_size2 (a);
- traits::detail::array<value_type> work(std::max<int>(1, n));
+ const std::ptrdiff_t n = traits::matrix_size2 (a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1, n));
return geqrf( a, tau, work );
}
@@ -151,8 +151,8 @@
template <typename A, typename Tau, typename Work>
int geqrf (A& a, Tau& tau, detail::workspace1<Work> workspace ) {
typedef typename A::value_type value_type ;
- const int n = traits::matrix_size2 (a);
- traits::detail::array<value_type> work(std::max<int>(1, n));
+ const std::ptrdiff_t n = traits::matrix_size2 (a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1, n));
return geqrf( a, tau, workspace.w_ );
}
Modified: sandbox/boost/numeric/bindings/lapack/gesdd.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gesdd.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gesdd.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -58,36 +58,36 @@
namespace detail {
inline
- void gesdd (char const jobz, int const m, int const n,
- float* a, int const lda,
- float* s, float* u, int const ldu,
- float* vt, int const ldvt,
- float* work, int const lwork, float* /* dummy */,
- int* iwork, int* info)
+ void gesdd (char const jobz, integer_t const m, integer_t const n,
+ float* a, integer_t const lda,
+ float* s, float* u, integer_t const ldu,
+ float* vt, integer_t const ldvt,
+ float* work, integer_t const lwork, float* /* dummy */,
+ integer_t* iwork, integer_t* info)
{
LAPACK_SGESDD (&jobz, &m, &n, a, &lda, s,
u, &ldu, vt, &ldvt, work, &lwork, iwork, info);
}
inline
- void gesdd (char const jobz, int const m, int const n,
- double* a, int const lda,
- double* s, double* u, int const ldu,
- double* vt, int const ldvt,
- double* work, int const lwork, double* /* dummy */,
- int* iwork, int* info)
+ void gesdd (char const jobz, integer_t const m, integer_t const n,
+ double* a, integer_t const lda,
+ double* s, double* u, integer_t const ldu,
+ double* vt, integer_t const ldvt,
+ double* work, integer_t const lwork, double* /* dummy */,
+ integer_t* iwork, integer_t* info)
{
LAPACK_DGESDD (&jobz, &m, &n, a, &lda, s,
u, &ldu, vt, &ldvt, work, &lwork, iwork, info);
}
inline
- void gesdd (char const jobz, int const m, int const n,
- traits::complex_f* a, int const lda,
- float* s, traits::complex_f* u, int const ldu,
- traits::complex_f* vt, int const ldvt,
- traits::complex_f* work, int const lwork,
- float* rwork, int* iwork, int* info)
+ void gesdd (char const jobz, integer_t const m, integer_t const n,
+ traits::complex_f* a, integer_t const lda,
+ float* s, traits::complex_f* u, integer_t const ldu,
+ traits::complex_f* vt, integer_t const ldvt,
+ traits::complex_f* work, integer_t const lwork,
+ float* rwork, integer_t* iwork, integer_t* info)
{
LAPACK_CGESDD (&jobz, &m, &n,
traits::complex_ptr (a), &lda, s,
@@ -98,12 +98,12 @@
}
inline
- void gesdd (char const jobz, int const m, int const n,
- traits::complex_d* a, int const lda,
- double* s, traits::complex_d* u, int const ldu,
- traits::complex_d* vt, int const ldvt,
- traits::complex_d* work, int const lwork,
- double* rwork, int* iwork, int* info)
+ void gesdd (char const jobz, integer_t const m, integer_t const n,
+ traits::complex_d* a, integer_t const lda,
+ double* s, traits::complex_d* u, integer_t const ldu,
+ traits::complex_d* vt, integer_t const ldvt,
+ traits::complex_d* work, integer_t const lwork,
+ double* rwork, integer_t* iwork, integer_t* info)
{
LAPACK_ZGESDD (&jobz, &m, &n,
traits::complex_ptr (a), &lda, s,
@@ -115,65 +115,65 @@
inline
- int gesdd_min_work (float, char jobz, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
- int m3 = 3 * minmn;
- int m4 = 4 * minmn;
- int minw;
+ integer_t gesdd_min_work (float, char jobz, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
+ integer_t m3 = 3 * minmn;
+ integer_t m4 = 4 * minmn;
+ integer_t minw;
if (jobz == 'N') {
// leading comments:
// LWORK >= 3*min(M,N) + max(max(M,N), 6*min(M,N))
// code:
// LWORK >= 3*min(M,N) + max(max(M,N), 7*min(M,N))
- int m7 = 7 * minmn;
+ integer_t m7 = 7 * minmn;
minw = maxmn < m7 ? m7 : maxmn;
minw += m3;
}
if (jobz == 'O') {
// LWORK >= 3*min(M,N)*min(M,N)
// + max(max(M,N), 5*min(M,N)*min(M,N)+4*min(M,N))
- int m5 = 5 * minmn * minmn + m4;
+ integer_t m5 = 5 * minmn * minmn + m4;
minw = maxmn < m5 ? m5 : maxmn;
minw += m3 * minmn;
}
if (jobz == 'S' || jobz == 'A') {
// LWORK >= 3*min(M,N)*min(M,N)
// + max(max(M,N), 4*min(M,N)*min(M,N)+4*min(M,N)).
- int m44 = m4 * minmn + m4;
+ integer_t m44 = m4 * minmn + m4;
minw = maxmn < m44 ? m44 : maxmn;
minw += m3 * minmn;
}
return minw;
}
inline
- int gesdd_min_work (double, char jobz, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
- int m3 = 3 * minmn;
- int m4 = 4 * minmn;
- int minw;
+ integer_t gesdd_min_work (double, char jobz, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
+ integer_t m3 = 3 * minmn;
+ integer_t m4 = 4 * minmn;
+ integer_t minw;
assert(jobz == 'N' || jobz == 'O' || jobz == 'S' || jobz == 'A');
if (jobz == 'N') {
// leading comments:
// LWORK >= 3*min(M,N) + max(max(M,N), 6*min(M,N))
// code:
// LWORK >= 3*min(M,N) + max(max(M,N), 7*min(M,N))
- int m7 = 7 * minmn;
+ integer_t m7 = 7 * minmn;
minw = maxmn < m7 ? m7 : maxmn;
minw += m3;
}
else if (jobz == 'O') {
// LWORK >= 3*min(M,N)*min(M,N)
// + max(max(M,N), 5*min(M,N)*min(M,N)+4*min(M,N))
- int m5 = 5 * minmn * minmn + m4;
+ integer_t m5 = 5 * minmn * minmn + m4;
minw = maxmn < m5 ? m5 : maxmn;
minw += m3 * minmn;
}
else if (jobz == 'S' || jobz == 'A') {
// LWORK >= 3*min(M,N)*min(M,N)
// + max(max(M,N), 4*min(M,N)*min(M,N)+4*min(M,N)).
- int m44 = m4 * minmn + m4;
+ integer_t m44 = m4 * minmn + m4;
minw = maxmn < m44 ? m44 : maxmn;
minw += m3 * minmn;
}
@@ -184,11 +184,11 @@
return minw;
}
inline
- int gesdd_min_work (traits::complex_f, char jobz, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
- int m2 = 2 * minmn;
- int minw = m2 + maxmn;
+ integer_t gesdd_min_work (traits::complex_f, char jobz, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
+ integer_t m2 = 2 * minmn;
+ integer_t minw = m2 + maxmn;
if (jobz == 'N')
// LWORK >= 2*min(M,N)+max(M,N)
;
@@ -201,11 +201,11 @@
return minw;
}
inline
- int gesdd_min_work (traits::complex_d, char jobz, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
- int m2 = 2 * minmn;
- int minw = m2 + maxmn;
+ integer_t gesdd_min_work (traits::complex_d, char jobz, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
+ integer_t m2 = 2 * minmn;
+ integer_t minw = m2 + maxmn;
if (jobz == 'N')
// LWORK >= 2*min(M,N)+max(M,N)
;
@@ -219,13 +219,13 @@
}
inline
- int gesdd_rwork (float, char, int, int) { return 1; }
+ integer_t gesdd_rwork (float, char, integer_t, integer_t) { return 1; }
inline
- int gesdd_rwork (double, char, int, int) { return 1; }
+ integer_t gesdd_rwork (double, char, integer_t, integer_t) { return 1; }
inline
- int gesdd_rwork (traits::complex_f, char jobz, int m, int n) {
- int minmn = m < n ? m : n;
- int minw;
+ integer_t gesdd_rwork (traits::complex_f, char jobz, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t minw;
if (jobz == 'N')
// LWORK >= 7*min(M,N)
minw = 7 * minmn;
@@ -235,9 +235,9 @@
return minw;
}
inline
- int gesdd_rwork (traits::complex_d, char jobz, int m, int n) {
- int minmn = m < n ? m : n;
- int minw;
+ integer_t gesdd_rwork (traits::complex_d, char jobz, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t minw;
if (jobz == 'N')
// LWORK >= 7*min(M,N)
minw = 7 * minmn;
@@ -248,8 +248,8 @@
}
inline
- int gesdd_iwork (int m, int n) {
- int minmn = m < n ? m : n;
+ integer_t gesdd_iwork (integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
return 8 * minmn;
}
@@ -257,7 +257,7 @@
template <typename MatrA>
- int gesdd_work (char const q, char const jobz, MatrA const& a)
+ integer_t gesdd_work (char const q, char const jobz, MatrA const& a)
{
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
@@ -274,9 +274,9 @@
#endif
assert (jobz == 'N' || jobz == 'O' || jobz == 'A' || jobz == 'S');
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
- int lw = -13;
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
+ integer_t lw = -13;
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<MatrA>::value_type val_t;
@@ -292,7 +292,7 @@
if (q == 'O') {
// traits::detail::array<val_t> w (1);
val_t w;
- int info;
+ integer_t info;
detail::gesdd (jobz, m, n,
traits::matrix_storage (a2),
traits::leading_dimension (a2),
@@ -315,8 +315,8 @@
* if m == 3, n == 4 and jobz == 'N' (real A),
* gesdd() returns optimal size == 1 while minimum size == 27
*/
- // int lwo = traits::detail::to_int (w);
- // int lwmin = detail::gesdd_min_work (val_t(), jobz, m, n);
+ // integer_t lwo = traits::detail::to_int (w);
+ // integer_t lwmin = detail::gesdd_min_work (val_t(), jobz, m, n);
// lw = lwo < lwmin ? lwmin : lwo;
}
#endif
@@ -326,7 +326,7 @@
template <typename MatrA>
- int gesdd_rwork (char jobz, MatrA const& a) {
+ integer_t gesdd_rwork (char jobz, MatrA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -350,7 +350,7 @@
template <typename MatrA>
- int gesdd_iwork (MatrA const& a) {
+ integer_t gesdd_iwork (MatrA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -394,9 +394,9 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
- int const minmn = m < n ? m : n;
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
+ integer_t const minmn = m < n ? m : n;
assert (minmn == traits::vector_size (s));
assert ((jobz == 'N')
@@ -433,7 +433,7 @@
>= detail::gesdd_min_work (val_t(), jobz, m, n));
assert (traits::vector_size (iw) >= detail::gesdd_iwork (m, n));
- int info;
+ integer_t info;
detail::gesdd (jobz, m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -472,9 +472,9 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
- int const minmn = m < n ? m : n;
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
+ integer_t const minmn = m < n ? m : n;
assert (minmn == traits::vector_size (s));
assert ((jobz == 'N')
@@ -513,7 +513,7 @@
>= detail::gesdd_rwork (val_t(), jobz, m, n));
assert (traits::vector_size (iw) >= detail::gesdd_iwork (m, n));
- int info;
+ integer_t info;
detail::gesdd (jobz, m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -551,10 +551,10 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
#ifndef NDEBUG
- int const minmn = m < n ? m : n;
+ integer_t const minmn = m < n ? m : n;
#endif // NDEBUG
assert (minmn == traits::vector_size (s));
@@ -597,19 +597,19 @@
#endif
typedef typename traits::type_traits<val_t>::real_type real_t;
- int const lw = gesdd_work (opt, jobz, a);
+ integer_t const lw = gesdd_work (opt, jobz, a);
traits::detail::array<val_t> w (lw);
if (!w.valid()) return -101;
- int const lrw = gesdd_rwork (jobz, a);
+ integer_t const lrw = gesdd_rwork (jobz, a);
traits::detail::array<real_t> rw (lrw);
if (!rw.valid()) return -102;
- int const liw = gesdd_iwork (a);
- traits::detail::array<int> iw (liw);
+ integer_t const liw = gesdd_iwork (a);
+ traits::detail::array<integer_t> iw (liw);
if (!iw.valid()) return -103;
- int info;
+ integer_t info;
detail::gesdd (jobz, m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -651,9 +651,9 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
- int const minmn = m < n ? m : n;
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
+ integer_t const minmn = m < n ? m : n;
assert (minmn == traits::vector_size (s));
@@ -664,19 +664,19 @@
#endif
typedef typename traits::type_traits<val_t>::real_type real_t;
- int const lw = gesdd_work ('O', 'N', a);
+ integer_t const lw = gesdd_work ('O', 'N', a);
traits::detail::array<val_t> w (lw);
if (!w.valid()) return -101;
- int const lrw = gesdd_rwork ('N', a);
+ integer_t const lrw = gesdd_rwork ('N', a);
traits::detail::array<real_t> rw (lrw);
if (!rw.valid()) return -102;
- int const liw = gesdd_iwork (a);
- traits::detail::array<int> iw (liw);
+ integer_t const liw = gesdd_iwork (a);
+ traits::detail::array<integer_t> iw (liw);
if (!iw.valid()) return -103;
- int info;
+ integer_t info;
detail::gesdd ('N', m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
Modified: sandbox/boost/numeric/bindings/lapack/gesv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gesv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gesv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -55,25 +55,25 @@
namespace detail {
inline
- void gesv (int const n, int const nrhs,
- float* a, int const lda, int* ipiv,
- float* b, int const ldb, int* info)
+ void gesv (integer_t const n, integer_t const nrhs,
+ float* a, integer_t const lda, integer_t* ipiv,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SGESV (&n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}
inline
- void gesv (int const n, int const nrhs,
- double* a, int const lda, int* ipiv,
- double* b, int const ldb, int* info)
+ void gesv (integer_t const n, integer_t const nrhs,
+ double* a, integer_t const lda, integer_t* ipiv,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DGESV (&n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}
inline
- void gesv (int const n, int const nrhs,
- traits::complex_f* a, int const lda, int* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void gesv (integer_t const n, integer_t const nrhs,
+ traits::complex_f* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CGESV (&n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -81,9 +81,9 @@
}
inline
- void gesv (int const n, int const nrhs,
- traits::complex_d* a, int const lda, int* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void gesv (integer_t const n, integer_t const nrhs,
+ traits::complex_d* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZGESV (&n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -106,12 +106,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (ipiv));
- int info;
+ integer_t info;
detail::gesv (n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -131,8 +131,8 @@
// if (info < 0), the -info argument had an illegal value
// -- we will use -101 if allocation fails
// if (info > 0), U(i-1,i-1) is exactly zero
- int info = -101;
- traits::detail::array<int> ipiv (traits::matrix_size1 (a));
+ integer_t info = -101;
+ traits::detail::array<integer_t> ipiv (traits::matrix_size1 (a));
if (ipiv.valid())
info = gesv (a, ipiv, b);
return info;
@@ -151,31 +151,31 @@
namespace detail {
inline
- void getrf (int const n, int const m,
- float* a, int const lda, int* ipiv, int* info)
+ void getrf (integer_t const n, integer_t const m,
+ float* a, integer_t const lda, integer_t* ipiv, integer_t* info)
{
LAPACK_SGETRF (&n, &m, a, &lda, ipiv, info);
}
inline
- void getrf (int const n, int const m,
- double* a, int const lda, int* ipiv, int* info)
+ void getrf (integer_t const n, integer_t const m,
+ double* a, integer_t const lda, integer_t* ipiv, integer_t* info)
{
LAPACK_DGETRF (&n, &m, a, &lda, ipiv, info);
}
inline
- void getrf (int const n, int const m,
- traits::complex_f* a, int const
- lda, int* ipiv, int* info)
+ void getrf (integer_t const n, integer_t const m,
+ traits::complex_f* a, integer_t const
+ lda, integer_t* ipiv, integer_t* info)
{
LAPACK_CGETRF (&n, &m, traits::complex_ptr (a), &lda, ipiv, info);
}
inline
- void getrf (int const n, int const m,
- traits::complex_d* a, int const lda,
- int* ipiv, int* info)
+ void getrf (integer_t const n, integer_t const m,
+ traits::complex_d* a, integer_t const lda,
+ integer_t* ipiv, integer_t* info)
{
LAPACK_ZGETRF (&n, &m, traits::complex_ptr (a), &lda, ipiv, info);
}
@@ -192,11 +192,11 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
- int const m = traits::matrix_size2 (a);
+ integer_t const n = traits::matrix_size1 (a);
+ integer_t const m = traits::matrix_size2 (a);
assert (traits::vector_size (ipiv) == (m < n ? m : n));
- int info;
+ integer_t info;
detail::getrf (n, m,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -215,26 +215,26 @@
namespace detail {
inline
- void getrs (char const trans, int const n, int const nrhs,
- float const* a, int const lda, int const* ipiv,
- float* b, int const ldb, int* info)
+ void getrs (char const trans, integer_t const n, integer_t const nrhs,
+ float const* a, integer_t const lda, integer_t const* ipiv,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}
inline
- void getrs (char const trans, int const n, int const nrhs,
- double const* a, int const lda, int const* ipiv,
- double* b, int const ldb, int* info)
+ void getrs (char const trans, integer_t const n, integer_t const nrhs,
+ double const* a, integer_t const lda, integer_t const* ipiv,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}
inline
- void getrs (char const trans, int const n, int const nrhs,
- traits::complex_f const* a, int const lda,
- int const* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void getrs (char const trans, integer_t const n, integer_t const nrhs,
+ traits::complex_f const* a, integer_t const lda,
+ integer_t const* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CGETRS (&trans, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -242,10 +242,10 @@
}
inline
- void getrs (char const trans, int const n, int const nrhs,
- traits::complex_d const* a, int const lda,
- int const* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void getrs (char const trans, integer_t const n, integer_t const nrhs,
+ traits::complex_d const* a, integer_t const lda,
+ integer_t const* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZGETRS (&trans, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -270,12 +270,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (ipiv));
- int info;
+ integer_t info;
detail::getrs (trans, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
@@ -309,32 +309,32 @@
namespace detail {
inline
- void getri (int const n, float* a, int const lda, int const* ipiv,
- float* work, int const lwork, int* info)
+ void getri (integer_t const n, float* a, integer_t const lda, integer_t const* ipiv,
+ float* work, integer_t const lwork, integer_t* info)
{
LAPACK_SGETRI (&n, a, &lda, ipiv, work, &lwork, info);
}
inline
- void getri (int const n, double* a, int const lda, int const* ipiv,
- double* work, int const lwork, int* info)
+ void getri (integer_t const n, double* a, integer_t const lda, integer_t const* ipiv,
+ double* work, integer_t const lwork, integer_t* info)
{
LAPACK_DGETRI (&n, a, &lda, ipiv, work, &lwork, info);
}
inline
- void getri (int const n, traits::complex_f* a, int const lda,
- int const* ipiv, traits::complex_f* work, int const lwork,
- int* info)
+ void getri (integer_t const n, traits::complex_f* a, integer_t const lda,
+ integer_t const* ipiv, traits::complex_f* work, integer_t const lwork,
+ integer_t* info)
{
LAPACK_CGETRI (&n, traits::complex_ptr (a), &lda, ipiv,
traits::complex_ptr (work), &lwork, info);
}
inline
- void getri (int const n, traits::complex_d* a, int const lda,
- int const* ipiv, traits::complex_d* work, int const lwork,
- int* info)
+ void getri (integer_t const n, traits::complex_d* a, integer_t const lda,
+ integer_t const* ipiv, traits::complex_d* work, integer_t const lwork,
+ integer_t* info)
{
LAPACK_ZGETRI (&n, traits::complex_ptr (a), &lda, ipiv,
traits::complex_ptr (work), &lwork, info);
@@ -352,14 +352,14 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n > 0);
assert (n <= traits::leading_dimension (a));
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (ipiv));
assert (n <= traits::vector_size (work)); //Minimal workspace size
- int info;
+ integer_t info;
//double* dummy = traits::matrix_storage (a);
detail::getri (n, traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -376,25 +376,25 @@
inline
- int getri_block(float)
+ integer_t getri_block(float)
{
return lapack::ilaenv(1, "sgetri", "");
}
inline
- int getri_block(double)
+ integer_t getri_block(double)
{
return lapack::ilaenv(1, "dgetri", "");
}
inline
- int getri_block(traits::complex_f)
+ integer_t getri_block(traits::complex_f)
{
return lapack::ilaenv(1, "cgetri", "");
}
inline
- int getri_block(traits::complex_d)
+ integer_t getri_block(traits::complex_d)
{
return lapack::ilaenv(1, "zgetri", "");
}
@@ -407,8 +407,8 @@
{
typedef typename MatrA::value_type value_type;
- int n = traits::matrix_size1(a);
- traits::detail::array<value_type> work(std::max<int>(1,n));
+ std::ptrdiff_t n = traits::matrix_size1(a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1,n));
return detail::getri(a, ipiv, work);
@@ -421,9 +421,9 @@
{
typedef typename MatrA::value_type value_type;
- int n = traits::matrix_size1(a);
- int nb = detail::getri_block(value_type());
- traits::detail::array<value_type> work(std::max<int>(1,n*nb));
+ std::ptrdiff_t n = traits::matrix_size1(a);
+ std::ptrdiff_t nb = detail::getri_block(value_type());
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1,n*nb));
return detail::getri(a, ipiv, work);
}
Modified: sandbox/boost/numeric/bindings/lapack/gesvd.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/gesvd.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/gesvd.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -58,11 +58,11 @@
inline
void gesvd (char const jobu, char const jobvt,
- int const m, int const n, float* a, int const lda,
- float* s, float* u, int const ldu,
- float* vt, int const ldvt,
- float* work, int const lwork, float* /* dummy */,
- int* info)
+ integer_t const m, integer_t const n, float* a, integer_t const lda,
+ float* s, float* u, integer_t const ldu,
+ float* vt, integer_t const ldvt,
+ float* work, integer_t const lwork, float* /* dummy */,
+ integer_t* info)
{
LAPACK_SGESVD (&jobu, &jobvt, &m, &n, a, &lda,
s, u, &ldu, vt, &ldvt, work, &lwork, info);
@@ -70,11 +70,11 @@
inline
void gesvd (char const jobu, char const jobvt,
- int const m, int const n, double* a, int const lda,
- double* s, double* u, int const ldu,
- double* vt, int const ldvt,
- double* work, int const lwork, double* /* dummy */,
- int* info)
+ integer_t const m, integer_t const n, double* a, integer_t const lda,
+ double* s, double* u, integer_t const ldu,
+ double* vt, integer_t const ldvt,
+ double* work, integer_t const lwork, double* /* dummy */,
+ integer_t* info)
{
LAPACK_DGESVD (&jobu, &jobvt, &m, &n, a, &lda,
s, u, &ldu, vt, &ldvt, work, &lwork, info);
@@ -82,12 +82,12 @@
inline
void gesvd (char const jobu, char const jobvt,
- int const m, int const n,
- traits::complex_f* a, int const lda,
- float* s, traits::complex_f* u, int const ldu,
- traits::complex_f* vt, int const ldvt,
- traits::complex_f* work, int const lwork,
- float* rwork, int* info)
+ integer_t const m, integer_t const n,
+ traits::complex_f* a, integer_t const lda,
+ float* s, traits::complex_f* u, integer_t const ldu,
+ traits::complex_f* vt, integer_t const ldvt,
+ traits::complex_f* work, integer_t const lwork,
+ float* rwork, integer_t* info)
{
LAPACK_CGESVD (&jobu, &jobvt, &m, &n,
traits::complex_ptr (a), &lda, s,
@@ -98,12 +98,12 @@
inline
void gesvd (char const jobu, char const jobvt,
- int const m, int const n,
- traits::complex_d* a, int const lda,
- double* s, traits::complex_d* u, int const ldu,
- traits::complex_d* vt, int const ldvt,
- traits::complex_d* work, int const lwork,
- double* rwork, int* info)
+ integer_t const m, integer_t const n,
+ traits::complex_d* a, integer_t const lda,
+ double* s, traits::complex_d* u, integer_t const ldu,
+ traits::complex_d* vt, integer_t const ldvt,
+ traits::complex_d* work, integer_t const lwork,
+ double* rwork, integer_t* info)
{
LAPACK_ZGESVD (&jobu, &jobvt, &m, &n,
traits::complex_ptr (a), &lda, s,
@@ -113,44 +113,44 @@
}
inline
- int gesvd_min_work (float, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
- int m3x = 3 * minmn + maxmn;
- int m5 = 5 * minmn;
+ integer_t gesvd_min_work (float, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
+ integer_t m3x = 3 * minmn + maxmn;
+ integer_t m5 = 5 * minmn;
return m3x < m5 ? m5 : m3x;
}
inline
- int gesvd_min_work (double, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
- int m3x = 3 * minmn + maxmn;
- int m5 = 5 * minmn;
+ integer_t gesvd_min_work (double, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
+ integer_t m3x = 3 * minmn + maxmn;
+ integer_t m5 = 5 * minmn;
return m3x < m5 ? m5 : m3x;
}
inline
- int gesvd_min_work (traits::complex_f, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
+ integer_t gesvd_min_work (traits::complex_f, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
return 2 * minmn + maxmn;
}
inline
- int gesvd_min_work (traits::complex_d, int m, int n) {
- int minmn = m < n ? m : n;
- int maxmn = m < n ? n : m;
+ integer_t gesvd_min_work (traits::complex_d, integer_t m, integer_t n) {
+ integer_t minmn = m < n ? m : n;
+ integer_t maxmn = m < n ? n : m;
return 2 * minmn + maxmn;
}
inline
- int gesvd_rwork (float, int, int) { return 1; }
+ integer_t gesvd_rwork (float, integer_t, integer_t) { return 1; }
inline
- int gesvd_rwork (double, int, int) { return 1; }
+ integer_t gesvd_rwork (double, integer_t, integer_t) { return 1; }
inline
- int gesvd_rwork (traits::complex_f, int m, int n) {
+ integer_t gesvd_rwork (traits::complex_f, integer_t m, integer_t n) {
return 5 * (m < n ? m : n);
}
inline
- int gesvd_rwork (traits::complex_d, int m, int n) {
+ integer_t gesvd_rwork (traits::complex_d, integer_t m, integer_t n) {
return 5 * (m < n ? m : n);
}
@@ -158,7 +158,7 @@
template <typename MatrA>
- int gesvd_work (char const q,
+ integer_t gesvd_work (char const q,
char const jobu, char const jobvt, MatrA const& a)
{
@@ -178,9 +178,9 @@
assert (jobvt == 'N' || jobvt == 'O' || jobvt == 'A' || jobvt == 'S');
assert (!(jobu == 'O' && jobvt == 'O'));
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
- int lw = -13;
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
+ integer_t lw = -13;
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<MatrA>::value_type val_t;
@@ -196,7 +196,7 @@
if (q == 'O') {
// traits::detail::array<val_t> w (0);
val_t w;
- int info;
+ integer_t info;
detail::gesvd (jobu, jobvt, m, n,
traits::matrix_storage (a2),
traits::leading_dimension (a2),
@@ -219,7 +219,7 @@
template <typename MatrA>
- int gesvd_rwork (MatrA const& a) {
+ integer_t gesvd_rwork (MatrA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -270,10 +270,10 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
#ifndef NDEBUG /* this variable is only used in assertions below */
- int const minmn = m < n ? m : n;
+ integer_t const minmn = m < n ? m : n;
#endif
assert (minmn == traits::vector_size (s));
@@ -298,7 +298,7 @@
#endif
assert (traits::vector_size(w) >= detail::gesvd_min_work(val_t(),m,n));
- int info;
+ integer_t info;
detail::gesvd (jobu, jobvt, m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -336,10 +336,10 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
#ifndef NDEBUG /* this variable is only used in assertions below */
- int const minmn = m < n ? m : n;
+ integer_t const minmn = m < n ? m : n;
#endif
assert (minmn == traits::vector_size (s));
@@ -365,7 +365,7 @@
assert (traits::vector_size(w) >= detail::gesvd_min_work(val_t(),m,n));
assert (traits::vector_size(rw) >= detail::gesvd_rwork(val_t(),m,n));
- int info;
+ integer_t info;
detail::gesvd (jobu, jobvt, m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -402,10 +402,10 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
#ifndef NDEBUG /* this variable is only used in assertions below */
- int const minmn = m < n ? m : n;
+ integer_t const minmn = m < n ? m : n;
#endif
assert (minmn == traits::vector_size (s));
@@ -437,15 +437,15 @@
#endif
typedef typename traits::type_traits<val_t>::real_type real_t;
- int const lw = gesvd_work (opt, jobu, jobvt, a);
+ integer_t const lw = gesvd_work (opt, jobu, jobvt, a);
traits::detail::array<val_t> w (lw);
if (!w.valid()) return -101;
- int const lrw = gesvd_rwork (a);
+ integer_t const lrw = gesvd_rwork (a);
traits::detail::array<real_t> rw (lrw);
if (!rw.valid()) return -102;
- int info;
+ integer_t info;
detail::gesvd (jobu, jobvt, m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -488,10 +488,10 @@
>::value));
#endif
- int const m = traits::matrix_size1 (a);
- int const n = traits::matrix_size2 (a);
+ integer_t const m = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size2 (a);
#ifndef NDEBUG /* this variable is only used in assertions below */
- int const minmn = m < n ? m : n;
+ integer_t const minmn = m < n ? m : n;
#endif
assert (minmn == traits::vector_size (s));
@@ -503,15 +503,15 @@
#endif
typedef typename traits::type_traits<val_t>::real_type real_t;
- int const lw = gesvd_work ('O', 'N', 'N', a);
+ integer_t const lw = gesvd_work ('O', 'N', 'N', a);
traits::detail::array<val_t> w (lw);
if (!w.valid()) return -101;
- int const lrw = gesvd_rwork (a);
+ integer_t const lrw = gesvd_rwork (a);
traits::detail::array<real_t> rw (lrw);
if (!rw.valid()) return -102;
- int info;
+ integer_t info;
detail::gesvd ('N', 'N', m, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
Modified: sandbox/boost/numeric/bindings/lapack/hbev.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/hbev.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/hbev.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -74,30 +74,28 @@
namespace detail {
inline
- void hbev (char const jobz, char const uplo, int const n, int const kd,
- float* ab, int const ldab, float* w, float* z, int const ldz,
- float* work, int& info)
+ void hbev (char const jobz, char const uplo, integer_t const n, integer_t const kd,
+ float* ab, integer_t const ldab, float* w, float* z, integer_t const ldz,
+ float* work, integer_t& info)
{
- //for (int i=0; i<n*kd; ++i) std::cout << *(ab+i) << " " ;
- //std::cout << "\n" ;
LAPACK_SSBEV (&jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz,
work, &info);
}
inline
- void hbev (char const jobz, char const uplo, int const n, int const kd,
- double* ab, int const ldab, double* w, double* z, int const ldz,
- double* work, int& info)
+ void hbev (char const jobz, char const uplo, integer_t const n, integer_t const kd,
+ double* ab, integer_t const ldab, double* w, double* z, integer_t const ldz,
+ double* work, integer_t& info)
{
LAPACK_DSBEV (&jobz, &uplo, &n, &kd, ab, &ldab, w, z, &ldz,
work, &info);
}
inline
- void hbev (char const jobz, char const uplo, int const n, int const kd,
- traits::complex_f* ab, int const ldab, float* w,
- traits::complex_f* z, int const ldz,
- traits::complex_f* work, float* rwork, int& info)
+ void hbev (char const jobz, char const uplo, integer_t const n, integer_t const kd,
+ traits::complex_f* ab, integer_t const ldab, float* w,
+ traits::complex_f* z, integer_t const ldz,
+ traits::complex_f* work, float* rwork, integer_t& info)
{
LAPACK_CHBEV (&jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
w, traits::complex_ptr(z), &ldz,
@@ -105,10 +103,10 @@
}
inline
- void hbev (char const jobz, char const uplo, int const n, int const kd,
- traits::complex_d* ab, int const ldab, double* w,
- traits::complex_d* z, int const ldz,
- traits::complex_d* work, double* rwork, int& info)
+ void hbev (char const jobz, char const uplo, integer_t const n, integer_t const kd,
+ traits::complex_d* ab, integer_t const ldab, double* w,
+ traits::complex_d* z, integer_t const ldz,
+ traits::complex_d* work, double* rwork, integer_t& info)
{
LAPACK_ZHBEV (&jobz, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
w, traits::complex_ptr(z), &ldz,
@@ -126,9 +124,9 @@
template <>
struct Hbev< 1 > {
template <typename T, typename R>
- void operator() (char const jobz, char const uplo, int const n,
- int const kd, T* ab, int const ldab, R* w, T* z,
- int const ldz, minimal_workspace , int& info ) const {
+ void operator() (char const jobz, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, R* w, T* z,
+ integer_t const ldz, minimal_workspace , integer_t& info ) const {
traits::detail::array<T> work( 3*n-2 );
hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz,
traits::vector_storage( work ),
@@ -136,9 +134,9 @@
}
template <typename T, typename R>
- void operator() (char const jobz, char const uplo, int const n,
- int const kd, T* ab, int const ldab, R* w, T* z,
- int const ldz, optimal_workspace , int& info ) const {
+ void operator() (char const jobz, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, R* w, T* z,
+ integer_t const ldz, optimal_workspace , integer_t& info ) const {
traits::detail::array<T> work( 3*n-2 );
hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz,
@@ -147,10 +145,10 @@
}
template <typename T, typename R, typename W>
- void operator() (char const jobz, char const uplo, int const n,
- int const kd, T* ab, int const ldab, R* w, T* z,
- int const ldz, detail::workspace1<W> work,
- int& info ) const {
+ void operator() (char const jobz, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, R* w, T* z,
+ integer_t const ldz, detail::workspace1<W> work,
+ integer_t& info ) const {
assert( traits::vector_size( work.w_ ) >= 3*n-2 );
hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz,
@@ -164,9 +162,9 @@
template <>
struct Hbev< 2 > {
template <typename T, typename R>
- void operator() (char const jobz, char const uplo, int const n,
- int const kd, T* ab, int const ldab, R* w, T* z,
- int const ldz, minimal_workspace , int& info ) const {
+ void operator() (char const jobz, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, R* w, T* z,
+ integer_t const ldz, minimal_workspace , integer_t& info ) const {
traits::detail::array<T> work( n );
traits::detail::array<R> rwork( 3*n-2 );
@@ -177,9 +175,9 @@
}
template <typename T, typename R>
- void operator() (char const jobz, char const uplo, int const n,
- int const kd, T* ab, int const ldab, R* w, T* z,
- int const ldz, optimal_workspace , int& info ) const {
+ void operator() (char const jobz, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, R* w, T* z,
+ integer_t const ldz, optimal_workspace , integer_t& info ) const {
traits::detail::array<T> work( n );
traits::detail::array<R> rwork( 3*n-2 );
@@ -190,10 +188,10 @@
}
template <typename T, typename R, typename W, typename RW>
- void operator() (char const jobz, char const uplo, int const n,
- int const kd, T* ab, int const ldab, R* w, T* z,
- int const ldz, detail::workspace2<W,RW> work,
- int& info ) const {
+ void operator() (char const jobz, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, R* w, T* z,
+ integer_t const ldz, detail::workspace2<W,RW> work,
+ integer_t& info ) const {
assert( traits::vector_size( work.wr_ ) >= 3*n-2 );
assert( traits::vector_size( work.w_ ) >= n );
@@ -231,12 +229,12 @@
typedef typename AB::value_type value_type ;
- int const n = traits::matrix_size2 (ab);
+ integer_t const n = traits::matrix_size2 (ab);
assert (n == traits::matrix_size1 (z));
assert (n == traits::vector_size (w));
assert ( jobz=='N' || jobz=='V' );
- int info ;
+ integer_t info ;
detail::Hbev< n_workspace_args<value_type>::value >() (jobz,
traits::matrix_uplo_tag( ab ), n,
traits::matrix_upper_bandwidth(ab),
@@ -268,7 +266,7 @@
typename traits::matrix_traits<Z>::matrix_structure,
traits::general_t
>::value));
- int const n = traits::matrix_size2 (ab);
+ std::ptrdiff_t const n = traits::matrix_size2 (ab);
assert (n == traits::matrix_size1 (z));
assert (n == traits::matrix_size2 (z));
return detail::hbev( 'V', ab, w, z, work );
Modified: sandbox/boost/numeric/bindings/lapack/hbevx.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/hbevx.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/hbevx.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -65,12 +65,12 @@
namespace detail {
inline
void hbevx (
- char const jobz, char const range, char const uplo, int const n, int const kd,
- float* ab, int const ldab, float* q, int const ldq,
- float const vl, float const vu, int const il, int const iu,
- float const abstol, int& m,
- float* w, float* z, int const ldz,
- float* work, int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n, integer_t const kd,
+ float* ab, integer_t const ldab, float* q, integer_t const ldq,
+ float const vl, float const vu, integer_t const il, integer_t const iu,
+ float const abstol, integer_t& m,
+ float* w, float* z, integer_t const ldz,
+ float* work, integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_SSBEVX (
&jobz, &range, &uplo, &n, &kd, ab, &ldab, q, &ldq,
@@ -81,12 +81,12 @@
inline
void hbevx (
- char const jobz, char const range, char const uplo, int const n, int const kd,
- double* ab, int const ldab, double* q, int const ldq,
- double const vl, double const vu, int const il, int const iu,
- double const abstol, int& m,
- double* w, double* z, int const ldz,
- double* work, int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n, integer_t const kd,
+ double* ab, integer_t const ldab, double* q, integer_t const ldq,
+ double const vl, double const vu, integer_t const il, integer_t const iu,
+ double const abstol, integer_t& m,
+ double* w, double* z, integer_t const ldz,
+ double* work, integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_DSBEVX (
&jobz, &range, &uplo, &n, &kd, ab, &ldab, q, &ldq,
@@ -97,12 +97,12 @@
inline
void hbevx (
- char const jobz, char const range, char const uplo, int const n, int const kd,
- traits::complex_f* ab, int const ldab, traits::complex_f* q, int const ldq,
- float const vl, float const vu, int const il, int const iu,
- float const abstol, int& m,
- float* w, traits::complex_f* z, int const ldz,
- traits::complex_f* work, float* rwork, int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n, integer_t const kd,
+ traits::complex_f* ab, integer_t const ldab, traits::complex_f* q, integer_t const ldq,
+ float const vl, float const vu, integer_t const il, integer_t const iu,
+ float const abstol, integer_t& m,
+ float* w, traits::complex_f* z, integer_t const ldz,
+ traits::complex_f* work, float* rwork, integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_CHBEVX (
&jobz, &range, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
@@ -114,12 +114,12 @@
inline
void hbevx (
- char const jobz, char const range, char const uplo, int const n, int const kd,
- traits::complex_d* ab, int const ldab, traits::complex_d* q, int const ldq,
- double const vl, double const vu, int const il, int const iu,
- double const abstol, int& m,
- double* w, traits::complex_d* z, int const ldz,
- traits::complex_d* work, double* rwork, int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n, integer_t const kd,
+ traits::complex_d* ab, integer_t const ldab, traits::complex_d* q, integer_t const ldq,
+ double const vl, double const vu, integer_t const il, integer_t const iu,
+ double const abstol, integer_t& m,
+ double* w, traits::complex_d* z, integer_t const ldz,
+ traits::complex_d* work, double* rwork, integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_ZHBEVX (
&jobz, &range, &uplo, &n, &kd, traits::complex_ptr(ab), &ldab,
@@ -140,14 +140,14 @@
template <>
struct Hbevx< 1 > {
template <typename T, typename R>
- void operator() (char const jobz, char const range, char const uplo, int const n,
- int const kd, T* ab, int const ldab, T* q, int const ldq,
- R vl, R vu, int const il, int const iu, R abstol, int& m,
- R* w, T* z, int const ldz,
- minimal_workspace, int* ifail, int& info ) const {
+ void operator() (char const jobz, char const range, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, T* q, integer_t const ldq,
+ R vl, R vu, integer_t const il, integer_t const iu, R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz,
+ minimal_workspace, integer_t* ifail, integer_t& info ) const {
traits::detail::array<T> work( 7*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
hbevx( jobz, range, uplo, n, kd, ab, ldab, q, ldq,
vl, vu, il, iu, abstol, m,
w, z, ldz,
@@ -157,14 +157,14 @@
}
template <typename T, typename R>
- void operator() (char const jobz, char const range, char const uplo, int const n,
- int const kd, T* ab, int const ldab, T* q, int const ldq,
- R vl, R vu, int const il, int const iu, R abstol, int& m,
- R* w, T* z, int const ldz,
- optimal_workspace, int* ifail, int& info ) const {
+ void operator() (char const jobz, char const range, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, T* q, integer_t const ldq,
+ R vl, R vu, integer_t const il, integer_t const iu, R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz,
+ optimal_workspace, integer_t* ifail, integer_t& info ) const {
traits::detail::array<T> work( 7*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
hbevx( jobz, range, uplo, n, kd, ab, ldab, q, ldq,
vl, vu, il, iu, abstol, m,
w, z, ldz,
@@ -174,12 +174,12 @@
}
template <typename T, typename R, typename W, typename WI>
- void operator() (char const jobz, char const range, char const uplo, int const n,
- int const kd, T* ab, int const ldab, T* q, int const ldq,
- R vl, R vu, int const il, int const iu, R abstol, int& m,
- R* w, T* z, int const ldz,
+ void operator() (char const jobz, char const range, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, T* q, integer_t const ldq,
+ R vl, R vu, integer_t const il, integer_t const iu, R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz,
std::pair<detail::workspace1<W>, detail::workspace1<WI> > work,
- int* ifail, int& info ) const {
+ integer_t* ifail, integer_t& info ) const {
assert( traits::vector_size( work.first.w_ ) >= 7*n );
assert( traits::vector_size( work.second.w_ ) >= 5*n );
@@ -197,15 +197,15 @@
template <>
struct Hbevx< 2 > {
template <typename T, typename R>
- void operator() (char const jobz, char const range, char const uplo, int const n,
- int const kd, T* ab, int const ldab, T* q, int const ldq,
- R vl, R vu, int const il, int const iu, R abstol, int& m,
- R* w, T* z, int const ldz,
- minimal_workspace, int* ifail, int& info ) const {
+ void operator() (char const jobz, char const range, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, T* q, integer_t const ldq,
+ R vl, R vu, integer_t const il, integer_t const iu, R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz,
+ minimal_workspace, integer_t* ifail, integer_t& info ) const {
traits::detail::array<T> work( n );
traits::detail::array<R> rwork( 7*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
hbevx( jobz, range, uplo, n, kd, ab, ldab, q, ldq,
vl, vu, il, iu, abstol, m,
w, z, ldz,
@@ -216,15 +216,15 @@
}
template <typename T, typename R>
- void operator() (char const jobz, char const range, char const uplo, int const n,
- int const kd, T* ab, int const ldab, T* q, int const ldq,
- R vl, R vu, int const il, int const iu, R abstol, int& m,
- R* w, T* z, int const ldz,
- optimal_workspace, int* ifail, int& info ) const {
+ void operator() (char const jobz, char const range, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, T* q, integer_t const ldq,
+ R vl, R vu, integer_t const il, integer_t const iu, R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz,
+ optimal_workspace, integer_t* ifail, integer_t& info ) const {
traits::detail::array<T> work( n );
traits::detail::array<R> rwork( 7*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
hbevx( jobz, range, uplo, n, kd, ab, ldab, q, ldq,
vl, vu, il, iu, abstol, m,
w, z, ldz,
@@ -235,12 +235,12 @@
}
template <typename T, typename R, typename W, typename RW, typename WI>
- void operator() (char const jobz, char const range, char const uplo, int const n,
- int const kd, T* ab, int const ldab, T* q, int const ldq,
- R vl, R vu, int const il, int const iu, R abstol, int& m,
- R* w, T* z, int const ldz,
+ void operator() (char const jobz, char const range, char const uplo, integer_t const n,
+ integer_t const kd, T* ab, integer_t const ldab, T* q, integer_t const ldq,
+ R vl, R vu, integer_t const il, integer_t const iu, R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz,
std::pair<detail::workspace2<W,RW>, detail::workspace1<WI> > work,
- int* ifail, int& info ) const {
+ integer_t* ifail, integer_t& info ) const {
assert( traits::vector_size( work.first.w_ ) >= n );
assert( traits::vector_size( work.first.wr_ ) >= 7*n );
@@ -257,7 +257,7 @@
} // namespace detail
template <typename AB, typename Q, typename R, typename Z, typename W, typename IFail, typename Work>
- int hbevx( char const jobz, char const range, AB& ab, Q& q, R vl, R vu, int il, int iu, R abstol, int& m,
+ int hbevx( char const jobz, char const range, AB& ab, Q& q, R vl, R vu, integer_t il, integer_t iu, R abstol, integer_t& m,
W& w, Z& z, IFail& ifail, Work work ) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -268,13 +268,13 @@
typedef typename AB::value_type value_type ;
- int const n = traits::matrix_size2 (ab);
+ integer_t const n = traits::matrix_size2 (ab);
assert (n == traits::matrix_size1 (z));
assert (n == traits::vector_size (w));
assert (n == traits::vector_size (ifail));
assert ( jobz=='N' || jobz=='V' );
- int info ;
+ integer_t info ;
detail::Hbevx< n_workspace_args<value_type>::value >() (jobz, range,
traits::matrix_uplo_tag( ab ), n,
traits::matrix_upper_bandwidth(ab),
Modified: sandbox/boost/numeric/bindings/lapack/heev.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/heev.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/heev.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -56,10 +56,10 @@
namespace detail {
inline
- void heev (char const jobz, char const uplo, int const n,
- traits::complex_f* a, int const lda,
- float* w, traits::complex_f* work, int const lwork,
- float* rwork, int& info)
+ void heev (char const jobz, char const uplo, integer_t const n,
+ traits::complex_f* a, integer_t const lda,
+ float* w, traits::complex_f* work, integer_t const lwork,
+ float* rwork, integer_t& info)
{
LAPACK_CHEEV (&jobz, &uplo, &n,
traits::complex_ptr(a), &lda, w,
@@ -68,10 +68,10 @@
}
inline
- void heev (char const jobz, char const uplo, int const n,
- traits::complex_d* a, int const lda,
- double* w, traits::complex_d* work, int const lwork,
- double* rwork, int& info)
+ void heev (char const jobz, char const uplo, integer_t const n,
+ traits::complex_d* a, integer_t const lda,
+ double* w, traits::complex_d* work, integer_t const lwork,
+ double* rwork, integer_t& info)
{
LAPACK_ZHEEV (&jobz, &uplo, &n,
traits::complex_ptr(a), &lda, w,
@@ -90,7 +90,7 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (traits::matrix_size2 (a)==n);
assert (traits::vector_size (w)==n);
assert (2*n-1 <= traits::vector_size (work));
@@ -98,7 +98,7 @@
assert ( uplo=='U' || uplo=='L' );
assert ( jobz=='N' || jobz=='V' );
- int info;
+ integer_t info;
detail::heev (jobz, uplo, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -118,10 +118,10 @@
typedef typename A::value_type value_type ;
typedef typename traits::type_traits<value_type>::real_type real_type ;
- int const n = traits::matrix_size1 (a);
+ std::ptrdiff_t const n = traits::matrix_size1 (a);
- traits::detail::array<value_type> work( std::max(1,2*n-1) );
- traits::detail::array<real_type> rwork( std::max(3*n-1,1) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,2*n-1) );
+ traits::detail::array<real_type> rwork( std::max<std::ptrdiff_t>(1,3*n-1) );
return detail::heev( jobz, uplo, a, w, work, rwork );
}
@@ -133,10 +133,10 @@
typedef typename A::value_type value_type ;
typedef typename traits::type_traits<value_type>::real_type real_type ;
- int const n = traits::matrix_size1 (a);
+ std::ptrdiff_t const n = traits::matrix_size1 (a);
- traits::detail::array<value_type> work( std::max(1,33*n) );
- traits::detail::array<real_type> rwork( std::max(3*n-1,1) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,33*n) );
+ traits::detail::array<real_type> rwork( std::max<std::ptrdiff_t>(1,3*n-1) );
return detail::heev( jobz, uplo, a, w, work, rwork );
}
Modified: sandbox/boost/numeric/bindings/lapack/heevd.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/heevd.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/heevd.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -62,10 +62,10 @@
namespace detail {
inline void heevd (
- char const jobz, char const uplo, int const n,
- float* a, int const lda,
- float* w, float* work, int const lwork,
- int* iwork, int const liwork, int& info)
+ char const jobz, char const uplo, integer_t const n,
+ float* a, integer_t const lda,
+ float* w, float* work, integer_t const lwork,
+ integer_t* iwork, integer_t const liwork, integer_t& info)
{
LAPACK_SSYEVD (
&jobz, &uplo, &n,
@@ -75,10 +75,10 @@
}
inline void heevd (
- char const jobz, char const uplo, int const n,
- double* a, int const lda,
- double* w, double* work, int const lwork,
- int* iwork, int const liwork, int& info)
+ char const jobz, char const uplo, integer_t const n,
+ double* a, integer_t const lda,
+ double* w, double* work, integer_t const lwork,
+ integer_t* iwork, integer_t const liwork, integer_t& info)
{
LAPACK_DSYEVD (
&jobz, &uplo, &n,
@@ -88,10 +88,10 @@
}
inline void heevd (
- char const jobz, char const uplo, int const n,
- traits::complex_f* a, int const lda,
- float* w, traits::complex_f* work, int const lwork,
- float* rwork, int const lrwork, int* iwork, int const liwork, int& info)
+ char const jobz, char const uplo, integer_t const n,
+ traits::complex_f* a, integer_t const lda,
+ float* w, traits::complex_f* work, integer_t const lwork,
+ float* rwork, integer_t const lrwork, integer_t* iwork, integer_t const liwork, integer_t& info)
{
LAPACK_CHEEVD (
&jobz, &uplo, &n,
@@ -102,10 +102,10 @@
}
inline void heevd (
- char const jobz, char const uplo, int const n,
- traits::complex_d* a, int const lda,
- double* w, traits::complex_d* work, int const lwork,
- double* rwork, int const lrwork, int* iwork, int const liwork, int& info)
+ char const jobz, char const uplo, integer_t const n,
+ traits::complex_d* a, integer_t const lda,
+ double* w, traits::complex_d* work, integer_t const lwork,
+ double* rwork, integer_t const lrwork, integer_t* iwork, integer_t const liwork, integer_t& info)
{
LAPACK_ZHEEVD (
&jobz, &uplo, &n,
@@ -127,12 +127,12 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const uplo, int const n,
- T* a, int const lda,
- R* w, minimal_workspace, int& info) {
+ char const jobz, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R* w, minimal_workspace, integer_t& info) {
traits::detail::array<T> work( jobz=='N' ? 1+2*n : 1+6*n+2*n*n );
- traits::detail::array<int> iwork( jobz=='N' ? 1 : 3+5*n );
+ traits::detail::array<integer_t> iwork( jobz=='N' ? 1 : 3+5*n );
heevd( jobz, uplo, n, a, lda, w,
traits::vector_storage (work), traits::vector_size (work),
@@ -142,11 +142,11 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const uplo, int const n,
- T* a, int const lda,
- R* w, optimal_workspace, int& info) {
+ char const jobz, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R* w, optimal_workspace, integer_t& info) {
- traits::detail::array<int> iwork( jobz=='N' ? 1 : 3+5*n );
+ traits::detail::array<integer_t> iwork( jobz=='N' ? 1 : 3+5*n );
T workspace_query;
heevd( jobz, uplo, n, a, lda, w,
@@ -164,9 +164,9 @@
// Function that uses given workarrays
template <typename T, typename R, typename W, typename WI>
void operator() (
- char const jobz, char const uplo, int const n,
- T* a, int const lda,
- R* w, std::pair<detail::workspace1<W>, detail::workspace1<WI> > work, int& info) {
+ char const jobz, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R* w, std::pair<detail::workspace1<W>, detail::workspace1<WI> > work, integer_t& info) {
assert (traits::vector_size (work.first.w_) >= jobz=='N' ? 1+2*n : 1+6*n+2*n*n);
assert (traits::vector_size (work.second.w_) >= jobz=='N' ? 1 : 3+5*n);
@@ -184,13 +184,13 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const uplo, int const n,
- T* a, int const lda,
- R* w, minimal_workspace, int& info) {
+ char const jobz, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R* w, minimal_workspace, integer_t& info) {
traits::detail::array<T> work( jobz=='N' ? 1+n : 2*n+n*n );
traits::detail::array<R> rwork( jobz=='N' ? n : 1+5*n+2*n*n );
- traits::detail::array<int> iwork( jobz=='N' ? 1 : 3+5*n );
+ traits::detail::array<integer_t> iwork( jobz=='N' ? 1 : 3+5*n );
heevd( jobz, uplo, n, a, lda, w,
traits::vector_storage (work), traits::vector_size (work),
@@ -201,12 +201,12 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const uplo, int const n,
- T* a, int const lda,
- R* w, optimal_workspace, int& info) {
+ char const jobz, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R* w, optimal_workspace, integer_t& info) {
traits::detail::array<R> rwork( jobz=='N' ? n : 1+5*n+2*n*n );
- traits::detail::array<int> iwork( jobz=='N' ? 1 : 3+5*n );
+ traits::detail::array<integer_t> iwork( jobz=='N' ? 1 : 3+5*n );
T workspace_query;
heevd( jobz, uplo, n, a, lda, w,
@@ -226,9 +226,9 @@
// Function that uses given workarrays
template <typename T, typename R, typename WC, typename WR, typename WI>
void operator() (
- char const jobz, char const uplo, int const n,
- T* a, int const lda,
- R* w, std::pair<detail::workspace2<WC,WR>, detail::workspace1<WI> > work, int& info) {
+ char const jobz, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R* w, std::pair<detail::workspace2<WC,WR>, detail::workspace1<WI> > work, integer_t& info) {
assert (traits::vector_size (work.first.w_) >= jobz=='N' ? 1+n : 2*n+n*n);
assert (traits::vector_size (work.first.wr_) >= jobz=='N' ? n : 1+5*n+2*n*n);
@@ -255,13 +255,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (traits::matrix_size2 (a) == n);
assert (traits::vector_size (w) == n);
assert ( uplo=='U' || uplo=='L' );
assert ( jobz=='N' || jobz=='V' );
- int info;
+ integer_t info;
detail::Heevd< n_workspace_args<typename A::value_type>::value >() (
jobz, uplo, n,
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/heevx.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/heevx.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/heevx.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -53,7 +53,7 @@
* On return of heevx, A is overwritten, z contains selected eigenvectors from Q
* and w contains selected eigenvalues from the main diagonal of D.
*
- * int heevx (char jobz, char range, char uplo, A& a, T vl, T vu, int il, int iu, T abstol, int& m,
+ * int heevx (char jobz, char range, char uplo, A& a, T vl, T vu, integer_t il, integer_t iu, T abstol, integer_t& m,
* W& w, Z& z, IFail& ifail, Work work) {
* jobz : 'V' : compute eigenvectors
* 'N' : do not compute eigenvectors
@@ -67,12 +67,12 @@
namespace detail {
inline void heevx (
- char const jobz, char const range, char const uplo, int const n,
- float* a, int const lda,
- float const vl, float const vu, int const il, int const iu,
- float const abstol, int& m,
- float* w, float* z, int const ldz, float* work, int const lwork,
- int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n,
+ float* a, integer_t const lda,
+ float const vl, float const vu, integer_t const il, integer_t const iu,
+ float const abstol, integer_t& m,
+ float* w, float* z, integer_t const ldz, float* work, integer_t const lwork,
+ integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_SSYEVX (
&jobz, &range, &uplo, &n,
@@ -84,12 +84,12 @@
}
inline void heevx (
- char const jobz, char const range, char const uplo, int const n,
- double* a, int const lda,
- double const vl, double const vu, int const il, int const iu,
- double const abstol, int& m,
- double* w, double* z, int const ldz, double* work, int const lwork,
- int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n,
+ double* a, integer_t const lda,
+ double const vl, double const vu, integer_t const il, integer_t const iu,
+ double const abstol, integer_t& m,
+ double* w, double* z, integer_t const ldz, double* work, integer_t const lwork,
+ integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_DSYEVX (
&jobz, &range, &uplo, &n,
@@ -101,12 +101,12 @@
}
inline void heevx (
- char const jobz, char const range, char const uplo, int const n,
- traits::complex_f* a, int const lda,
- float const vl, float const vu, int const il, int const iu,
- float const abstol, int& m,
- float* w, traits::complex_f* z, int const ldz, traits::complex_f* work, int const lwork,
- float* rwork, int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n,
+ traits::complex_f* a, integer_t const lda,
+ float const vl, float const vu, integer_t const il, integer_t const iu,
+ float const abstol, integer_t& m,
+ float* w, traits::complex_f* z, integer_t const ldz, traits::complex_f* work, integer_t const lwork,
+ float* rwork, integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_CHEEVX (
&jobz, &range, &uplo, &n,
@@ -118,12 +118,12 @@
}
inline void heevx (
- char const jobz, char const range, char const uplo, int const n,
- traits::complex_d* a, int const lda,
- double const vl, double const vu, int const il, int const iu,
- double const abstol, int& m,
- double* w, traits::complex_d* z, int const ldz, traits::complex_d* work, int const lwork,
- double* rwork, int* iwork, int* ifail, int& info)
+ char const jobz, char const range, char const uplo, integer_t const n,
+ traits::complex_d* a, integer_t const lda,
+ double const vl, double const vu, integer_t const il, integer_t const iu,
+ double const abstol, integer_t& m,
+ double* w, traits::complex_d* z, integer_t const ldz, traits::complex_d* work, integer_t const lwork,
+ double* rwork, integer_t* iwork, integer_t* ifail, integer_t& info)
{
LAPACK_ZHEEVX (
&jobz, &range, &uplo, &n,
@@ -146,14 +146,14 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const range, char const uplo, int const n,
- T* a, int const lda,
- R vl, R vu, int const il, int const iu,
- R abstol, int& m,
- R* w, T* z, int const ldz, minimal_workspace, int* ifail, int& info) {
+ char const jobz, char const range, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R vl, R vu, integer_t const il, integer_t const iu,
+ R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz, minimal_workspace, integer_t* ifail, integer_t& info) {
traits::detail::array<T> work( 8*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
heevx( jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz,
traits::vector_storage (work), traits::vector_size (work),
@@ -163,13 +163,13 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const range, char const uplo, int const n,
- T* a, int const lda,
- R vl, R vu, int const il, int const iu,
- R abstol, int& m,
- R* w, T* z, int const ldz, optimal_workspace, int* ifail, int& info) {
+ char const jobz, char const range, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R vl, R vu, integer_t const il, integer_t const iu,
+ R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz, optimal_workspace, integer_t* ifail, integer_t& info) {
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
T workspace_query;
heevx( jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz,
@@ -187,11 +187,11 @@
// Function that uses given workarrays
template <typename T, typename R, typename W, typename WI>
void operator() (
- char const jobz, char const range, char const uplo, int const n,
- T* a, int const lda,
- R vl, R vu, int const il, int const iu,
- R abstol, int& m,
- R* w, T* z, int const ldz, std::pair<detail::workspace1<W>, detail::workspace1<WI> > work, int* ifail, int& info) {
+ char const jobz, char const range, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R vl, R vu, integer_t const il, integer_t const iu,
+ R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz, std::pair<detail::workspace1<W>, detail::workspace1<WI> > work, integer_t* ifail, integer_t& info) {
assert (traits::vector_size (work.first.w_) >= 8*n);
assert (traits::vector_size (work.second.w_) >= 5*n);
@@ -209,15 +209,15 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const range, char const uplo, int const n,
- T* a, int const lda,
- R vl, R vu, int const il, int const iu,
- R abstol, int& m,
- R* w, T* z, int const ldz, minimal_workspace, int* ifail, int& info) {
+ char const jobz, char const range, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R vl, R vu, integer_t const il, integer_t const iu,
+ R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz, minimal_workspace, integer_t* ifail, integer_t& info) {
traits::detail::array<T> work( 2*n );
traits::detail::array<R> rwork( 7*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
heevx( jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz,
traits::vector_storage (work), traits::vector_size (work),
@@ -228,14 +228,14 @@
// Function that allocates temporary arrays
template <typename T, typename R>
void operator() (
- char const jobz, char const range, char const uplo, int const n,
- T* a, int const lda,
- R vl, R vu, int const il, int const iu,
- R abstol, int& m,
- R* w, T* z, int const ldz, optimal_workspace, int* ifail, int& info) {
+ char const jobz, char const range, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R vl, R vu, integer_t const il, integer_t const iu,
+ R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz, optimal_workspace, integer_t* ifail, integer_t& info) {
traits::detail::array<R> rwork( 7*n );
- traits::detail::array<int> iwork( 5*n );
+ traits::detail::array<integer_t> iwork( 5*n );
T workspace_query;
heevx( jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz,
@@ -255,11 +255,11 @@
// Function that uses given workarrays
template <typename T, typename R, typename WC, typename WR, typename WI>
void operator() (
- char const jobz, char const range, char const uplo, int const n,
- T* a, int const lda,
- R vl, R vu, int const il, int const iu,
- R abstol, int& m,
- R* w, T* z, int const ldz, std::pair<detail::workspace2<WC,WR>, detail::workspace1<WI> > work, int* ifail, int& info) {
+ char const jobz, char const range, char const uplo, integer_t const n,
+ T* a, integer_t const lda,
+ R vl, R vu, integer_t const il, integer_t const iu,
+ R abstol, integer_t& m,
+ R* w, T* z, integer_t const ldz, std::pair<detail::workspace2<WC,WR>, detail::workspace1<WI> > work, integer_t* ifail, integer_t& info) {
assert (traits::vector_size (work.first.w_) >= 2*n);
assert (traits::vector_size (work.first.wr_) >= 7*n);
@@ -276,7 +276,7 @@
template <typename A, typename T, typename W, typename Z, typename IFail, typename Work>
int heevx (
- char jobz, char range, A& a, T vl, T vu, int il, int iu, T abstol, int& m,
+ char jobz, char range, A& a, T vl, T vu, integer_t il, integer_t iu, T abstol, integer_t& m,
W& w, Z& z, IFail& ifail, Work work = optimal_workspace() ) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
@@ -291,7 +291,7 @@
>::value && boost::is_same<value_type, real_type>::value)));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (traits::matrix_size2 (a) == n);
assert (traits::vector_size (w) == n);
assert (traits::vector_size (ifail) == n);
@@ -300,7 +300,7 @@
assert ( uplo=='U' || uplo=='L' );
assert ( jobz=='N' || jobz=='V' );
- int info;
+ integer_t info;
detail::Heevx< n_workspace_args<typename A::value_type>::value >() (
jobz, range, uplo, n,
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/hegv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/hegv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/hegv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -121,34 +121,34 @@
namespace detail {
inline
- void hegv (int const itype, char const jobz, char const uplo, int const n,
- float *a, int const lda, float *b, int const ldb,
- float *w, float *work, int const lwork, int& info)
+ void hegv (integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ float *a, integer_t const lda, float *b, integer_t const ldb,
+ float *w, float *work, integer_t const lwork, integer_t& info)
{
LAPACK_SSYGV (&itype, &jobz, &uplo, &n, a, &lda, b, &ldb, w, work, &lwork, &info);
}
inline
- void hegv (int const itype, char const jobz, char const uplo, int const n,
- double *a, int const lda, double *b, int const ldb,
- double *w, double *work, int const lwork, int& info)
+ void hegv (integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ double *a, integer_t const lda, double *b, integer_t const ldb,
+ double *w, double *work, integer_t const lwork, integer_t& info)
{
LAPACK_DSYGV (&itype, &jobz, &uplo, &n, a, &lda, b, &ldb, w, work, &lwork, &info);
}
inline
- void hegv (int const itype, char const jobz, char const uplo, int const n,
- traits::complex_f *a, int const lda, traits::complex_f *b, int const ldb,
- float *w, traits::complex_f *work, int const lwork, float *rwork, int& info)
+ void hegv (integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ traits::complex_f *a, integer_t const lda, traits::complex_f *b, integer_t const ldb,
+ float *w, traits::complex_f *work, integer_t const lwork, float *rwork, integer_t& info)
{
LAPACK_CHEGV (&itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work), &lwork, rwork, &info);
}
inline
- void hegv (int const itype, char const jobz, char const uplo, int const n,
- traits::complex_d *a, int const lda, traits::complex_d *b, int const ldb,
- double *w, traits::complex_d *work, int const lwork, double *rwork, int& info)
+ void hegv (integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ traits::complex_d *a, integer_t const lda, traits::complex_d *b, integer_t const ldb,
+ double *w, traits::complex_d *work, integer_t const lwork, double *rwork, integer_t& info)
{
LAPACK_ZHEGV (&itype, &jobz, &uplo, &n, traits::complex_ptr(a), &lda,
traits::complex_ptr(b), &ldb, w, traits::complex_ptr(work), &lwork, rwork, &info);
@@ -166,11 +166,11 @@
// Function that allocates work arrays
template <typename T, typename R>
void operator() (
- int const itype, char const jobz, char const uplo, int const n,
- T *a, int const lda, T *b, int const ldb,
- R *w, optimal_workspace, int& info ) {
+ integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ T *a, integer_t const lda, T *b, integer_t const ldb,
+ R *w, optimal_workspace, integer_t& info ) {
- traits::detail::array<T> work( std::max<int>(1,34*n) );
+ traits::detail::array<T> work( std::max<integer_t>(1,34*n) );
detail::hegv(itype, jobz, uplo, n, a, lda, b, ldb, w,
traits::vector_storage (work), traits::vector_size (work), info);
@@ -178,11 +178,11 @@
// Function that allocates work arrays
template <typename T, typename R>
void operator() (
- int const itype, char const jobz, char const uplo, int const n,
- T *a, int const lda, T *b, int const ldb,
- R *w, minimal_workspace, int& info ) {
+ integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ T *a, integer_t const lda, T *b, integer_t const ldb,
+ R *w, minimal_workspace, integer_t& info ) {
- traits::detail::array<T> work( std::max<int>(1,3*n-1) );
+ traits::detail::array<T> work( std::max<integer_t>(1,3*n-1) );
detail::hegv(itype, jobz, uplo, n, a, lda, b, ldb, w,
traits::vector_storage (work), traits::vector_size (work), info);
@@ -190,9 +190,9 @@
// Function that uses given workarrays
template <typename T, typename R, typename W>
void operator() (
- int const itype, char const jobz, char const uplo, int const n,
- T *a, int const lda, T *b, int const ldb,
- R *w, detail::workspace1<W> work, int& info ) {
+ integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ T *a, integer_t const lda, T *b, integer_t const ldb,
+ R *w, detail::workspace1<W> work, integer_t& info ) {
assert (traits::vector_size (work.w_) >= 3*n-1);
@@ -207,12 +207,12 @@
// Function that allocates work arrays
template <typename T, typename R>
void operator() (
- int const itype, char const jobz, char const uplo, int const n,
- T *a, int const lda, T *b, int const ldb,
- R *w, optimal_workspace, int& info ) {
+ integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ T *a, integer_t const lda, T *b, integer_t const ldb,
+ R *w, optimal_workspace, integer_t& info ) {
- traits::detail::array<T> work( std::max<int>(1,34*n) );
- traits::detail::array<R> rwork( std::max<int>(1,3*n-2) );
+ traits::detail::array<T> work( std::max<integer_t>(1,34*n) );
+ traits::detail::array<R> rwork( std::max<integer_t>(1,3*n-2) );
detail::hegv(itype, jobz, uplo, n, a, lda, b, ldb, w,
traits::vector_storage (work), traits::vector_size (work),
@@ -221,12 +221,12 @@
// Function that allocates work arrays
template <typename T, typename R>
void operator() (
- int const itype, char const jobz, char const uplo, int const n,
- T *a, int const lda, T *b, int const ldb,
- R *w, minimal_workspace, int& info ) {
+ integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ T *a, integer_t const lda, T *b, integer_t const ldb,
+ R *w, minimal_workspace, integer_t& info ) {
- traits::detail::array<T> work( std::max<int>(1,2*n-1) );
- traits::detail::array<R> rwork( std::max<int>(1,3*n-2) );
+ traits::detail::array<T> work( std::max<integer_t>(1,2*n-1) );
+ traits::detail::array<R> rwork( std::max<integer_t>(1,3*n-2) );
detail::hegv(itype, jobz, uplo, n, a, lda, b, ldb, w,
traits::vector_storage (work), traits::vector_size (work),
@@ -235,9 +235,9 @@
// Function that uses given workarrays
template <typename T, typename R, typename WC, typename WR>
void operator() (
- int const itype, char const jobz, char const uplo, int const n,
- T *a, int const lda, T *b, int const ldb,
- R *w, detail::workspace2<WC,WR> work, int& info ) {
+ integer_t const itype, char const jobz, char const uplo, integer_t const n,
+ T *a, integer_t const lda, T *b, integer_t const ldb,
+ R *w, detail::workspace2<WC,WR> work, integer_t& info ) {
assert (traits::vector_size (work.w_) >= 2*n-1);
assert (traits::vector_size (work.wr_) >= 3*n-2);
@@ -249,7 +249,7 @@
}; } // namespace detail
template <typename A, typename B, typename W, typename Work>
- int hegv (int itype, char jobz, char uplo, A& a, B& b, W& w, Work work = optimal_workspace()) {
+ int hegv (integer_t itype, char jobz, char uplo, A& a, B& b, W& w, Work work = optimal_workspace()) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -258,13 +258,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert ( n>0 );
assert (traits::matrix_size2 (a)==n);
assert (traits::leading_dimension (a)>=n);
assert (traits::vector_size (w)==n);
- int const nb = traits::matrix_size1 (b);
+ integer_t const nb = traits::matrix_size1 (b);
assert ( nb>0 );
assert (traits::matrix_size2 (b)==nb);
assert (traits::leading_dimension (b)>=nb);
@@ -276,7 +276,7 @@
assert( itype==1 || itype==2 || itype==3);
- int info;
+ integer_t info;
detail::Hegv< n_workspace_args<typename A::value_type>::value >() (
itype, jobz, uplo, n,
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/hesv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/hesv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/hesv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -42,15 +42,15 @@
namespace detail {
inline
- int hetrf_block (traits::complex_f,
- int const ispec, char const ul, int const n)
+ integer_t hetrf_block (traits::complex_f,
+ integer_t const ispec, char const ul, integer_t const n)
{
char ul2[2] = "x"; ul2[0] = ul;
return ilaenv (ispec, "CHETRF", ul2, n);
}
inline
- int hetrf_block (traits::complex_d,
- int const ispec, char const ul, int const n)
+ integer_t hetrf_block (traits::complex_d,
+ integer_t const ispec, char const ul, integer_t const n)
{
char ul2[2] = "x"; ul2[0] = ul;
return ilaenv (ispec, "ZHETRF", ul2, n);
@@ -60,7 +60,7 @@
template <typename HermA>
- int hetrf_block (char const q, char const ul, HermA const& a) {
+ integer_t hetrf_block (char const q, char const ul, HermA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -71,7 +71,7 @@
assert (q == 'O' || q == 'M');
assert (ul == 'U' || ul == 'L');
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -79,12 +79,12 @@
#else
typedef typename HermA::value_type val_t;
#endif
- int ispec = (q == 'O' ? 1 : 2);
+ integer_t ispec = (q == 'O' ? 1 : 2);
return detail::hetrf_block (val_t(), ispec, ul, n);
}
template <typename HermA>
- int hetrf_block (char const q, HermA const& a) {
+ integer_t hetrf_block (char const q, HermA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -95,7 +95,7 @@
assert (q == 'O' || q == 'M');
char ul = traits::matrix_uplo_tag (a);
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -103,12 +103,12 @@
#else
typedef typename HermA::value_type val_t;
#endif
- int ispec = (q == 'O' ? 1 : 2);
+ integer_t ispec = (q == 'O' ? 1 : 2);
return detail::hetrf_block (val_t(), ispec, ul, n);
}
template <typename HermA>
- int hetrf_work (char const q, char const ul, HermA const& a) {
+ integer_t hetrf_work (char const q, char const ul, HermA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -119,7 +119,7 @@
assert (q == 'O' || q == 'M');
assert (ul == 'U' || ul == 'L');
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -127,7 +127,7 @@
#else
typedef typename HermA::value_type val_t;
#endif
- int lw = -13;
+ integer_t lw = -13;
if (q == 'M')
lw = 1;
if (q == 'O')
@@ -136,7 +136,7 @@
}
template <typename HermA>
- int hetrf_work (char const q, HermA const& a) {
+ integer_t hetrf_work (char const q, HermA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -147,7 +147,7 @@
assert (q == 'O' || q == 'M');
char ul = traits::matrix_uplo_tag (a);
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -155,7 +155,7 @@
#else
typedef typename HermA::value_type val_t;
#endif
- int lw = -13;
+ integer_t lw = -13;
if (q == 'M')
lw = 1;
if (q == 'O')
@@ -166,13 +166,13 @@
template <typename HermA>
inline
- int hesv_work (char const q, char const ul, HermA const& a) {
+ integer_t hesv_work (char const q, char const ul, HermA const& a) {
return hetrf_work (q, ul, a);
}
template <typename HermA>
inline
- int hesv_work (char const q, HermA const& a) { return hetrf_work (q, a); }
+ integer_t hesv_work (char const q, HermA const& a) { return hetrf_work (q, a); }
/*
@@ -192,10 +192,10 @@
namespace detail {
inline
- void hesv (char const uplo, int const n, int const nrhs,
- traits::complex_f* a, int const lda, int* ipiv,
- traits::complex_f* b, int const ldb,
- traits::complex_f* w, int const lw, int* info)
+ void hesv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_f* b, integer_t const ldb,
+ traits::complex_f* w, integer_t const lw, integer_t* info)
{
LAPACK_CHESV (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -204,10 +204,10 @@
}
inline
- void hesv (char const uplo, int const n, int const nrhs,
- traits::complex_d* a, int const lda, int* ipiv,
- traits::complex_d* b, int const ldb,
- traits::complex_d* w, int const lw, int* info)
+ void hesv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_d* b, integer_t const ldb,
+ traits::complex_d* w, integer_t const lw, integer_t* info)
{
LAPACK_ZHESV (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -218,12 +218,12 @@
template <typename HermA, typename MatrB, typename IVec, typename Work>
int hesv (char const ul, HermA& a, IVec& i, MatrB& b, Work& w) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (i));
- int info;
+ integer_t info;
hesv (ul, n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -254,7 +254,7 @@
>::value));
#endif
- int const lw = traits::vector_size (w);
+ integer_t const lw = traits::vector_size (w);
assert (lw >= 1);
return detail::hesv (ul, a, i, b, w);
}
@@ -273,7 +273,7 @@
>::value));
#endif
- int const lw = traits::vector_size (w);
+ integer_t const lw = traits::vector_size (w);
assert (lw >= 1);
char uplo = traits::matrix_uplo_tag (a);
return detail::hesv (uplo, a, i, b, w);
@@ -296,13 +296,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
- int info = -101;
- traits::detail::array<int> i (n);
+ integer_t const n = traits::matrix_size1 (a);
+ integer_t info = -101;
+ traits::detail::array<integer_t> i (n);
if (i.valid()) {
info = -102;
- int lw = hetrf_work ('O', ul, a);
+ integer_t lw = hetrf_work ('O', ul, a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<HermA>::value_type val_t;
@@ -331,14 +331,14 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
char uplo = traits::matrix_uplo_tag (a);
- int info = -101;
- traits::detail::array<int> i (n);
+ integer_t info = -101;
+ traits::detail::array<integer_t> i (n);
if (i.valid()) {
info = -102;
- int lw = hetrf_work ('O', a);
+ integer_t lw = hetrf_work ('O', a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<HermA>::value_type val_t;
@@ -367,9 +367,9 @@
namespace detail {
inline
- void hetrf (char const uplo, int const n,
- traits::complex_f* a, int const lda, int* ipiv,
- traits::complex_f* w, int const lw, int* info)
+ void hetrf (char const uplo, integer_t const n,
+ traits::complex_f* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_f* w, integer_t const lw, integer_t* info)
{
LAPACK_CHETRF (&uplo, &n,
traits::complex_ptr (a), &lda, ipiv,
@@ -377,9 +377,9 @@
}
inline
- void hetrf (char const uplo, int const n,
- traits::complex_d* a, int const lda, int* ipiv,
- traits::complex_d* w, int const lw, int* info)
+ void hetrf (char const uplo, integer_t const n,
+ traits::complex_d* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_d* w, integer_t const lw, integer_t* info)
{
LAPACK_ZHETRF (&uplo, &n,
traits::complex_ptr (a), &lda, ipiv,
@@ -389,11 +389,11 @@
template <typename HermA, typename IVec, typename Work>
int hetrf (char const ul, HermA& a, IVec& i, Work& w) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (i));
- int info;
+ integer_t info;
hetrf (ul, n, traits::matrix_storage (a),
traits::leading_dimension (a),
traits::vector_storage (i),
@@ -417,7 +417,7 @@
>::value));
#endif
- int const lw = traits::vector_size (w);
+ std::ptrdiff_t const lw = traits::vector_size (w);
assert (lw >= 1);
return detail::hetrf (ul, a, i, w);
}
@@ -432,7 +432,7 @@
>::value));
#endif
- int const lw = traits::vector_size (w);
+ std::ptrdiff_t const lw = traits::vector_size (w);
assert (lw >= 1);
char uplo = traits::matrix_uplo_tag (a);
return detail::hetrf (uplo, a, i, w);
@@ -451,8 +451,8 @@
>::value));
#endif
- int info = -101;
- int lw = hetrf_work ('O', ul, a);
+ integer_t info = -101;
+ integer_t lw = hetrf_work ('O', ul, a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<HermA>::value_type val_t;
@@ -477,8 +477,8 @@
#endif
char uplo = traits::matrix_uplo_tag (a);
- int info = -101;
- int lw = hetrf_work ('O', a);
+ integer_t info = -101;
+ integer_t lw = hetrf_work ('O', a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<HermA>::value_type val_t;
@@ -502,10 +502,10 @@
namespace detail {
inline
- void hetrs (char const uplo, int const n, int const nrhs,
- traits::complex_f const* a, int const lda,
- int const* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void hetrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f const* a, integer_t const lda,
+ integer_t const* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CHETRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -513,10 +513,10 @@
}
inline
- void hetrs (char const uplo, int const n, int const nrhs,
- traits::complex_d const* a, int const lda,
- int const* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void hetrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d const* a, integer_t const lda,
+ integer_t const* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZHETRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -526,12 +526,12 @@
template <typename HermA, typename MatrB, typename IVec>
int hetrs (char const ul, HermA const& a, IVec const& i, MatrB& b) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (i));
- int info;
+ integer_t info;
hetrs (ul, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/hpsv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/hpsv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/hpsv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -54,9 +54,9 @@
namespace detail {
inline
- void hpsv (char const uplo, int const n, int const nrhs,
- traits::complex_f* ap, int* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void hpsv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f* ap, integer_t* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CHPSV (&uplo, &n, &nrhs,
traits::complex_ptr (ap), ipiv,
@@ -64,9 +64,9 @@
}
inline
- void hpsv (char const uplo, int const n, int const nrhs,
- traits::complex_d* ap, int* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void hpsv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d* ap, integer_t* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZHPSV (&uplo, &n, &nrhs,
traits::complex_ptr (ap), ipiv,
@@ -87,12 +87,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
hpsv (uplo, n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::vector_storage (i),
@@ -115,8 +115,8 @@
int hpsv (HermA& a, MatrB& b) {
// with 'internal' pivot vector
- int info = -101;
- traits::detail::array<int> i (traits::matrix_size1 (a));
+ integer_t info = -101;
+ traits::detail::array<integer_t> i (traits::matrix_size1 (a));
if (i.valid())
info = detail::hpsv (a, i, b);
@@ -137,22 +137,22 @@
namespace detail {
inline
- void hptrf (char const uplo, int const n,
- traits::complex_f* ap, int* ipiv, int* info)
+ void hptrf (char const uplo, integer_t const n,
+ traits::complex_f* ap, integer_t* ipiv, integer_t* info)
{
LAPACK_CHPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info);
}
inline
- void hptrf (char const uplo, int const n,
- traits::complex_d* ap, int* ipiv, int* info)
+ void hptrf (char const uplo, integer_t const n,
+ traits::complex_d* ap, integer_t* ipiv, integer_t* info)
{
LAPACK_ZHPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info);
}
template <typename HermA, typename IVec, typename Work>
inline
- int hptrf (char const ul, HermA& a, IVec& i, Work& w, int const lw) {
+ int hptrf (char const ul, HermA& a, IVec& i, Work& w, integer_t const lw) {
}
@@ -168,12 +168,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (i));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::hptrf (uplo, n, traits::matrix_storage (a),
traits::vector_storage (i), &info);
return info;
@@ -190,9 +190,9 @@
namespace detail {
inline
- void hptrs (char const uplo, int const n, int const nrhs,
- traits::complex_f const* ap, int const* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void hptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f const* ap, integer_t const* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CHPTRS (&uplo, &n, &nrhs,
traits::complex_ptr (ap), ipiv,
@@ -200,9 +200,9 @@
}
inline
- void hptrs (char const uplo, int const n, int const nrhs,
- traits::complex_d const* ap, int const* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void hptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d const* ap, integer_t const* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZHPTRS (&uplo, &n, &nrhs,
traits::complex_ptr (ap), ipiv,
@@ -225,13 +225,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (i));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::hptrs (uplo, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/hseqr.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/hseqr.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/hseqr.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -94,11 +94,11 @@
namespace detail {
// float
inline
- int hseqr_backend(const char* job, const char* compz, const int* n,
- const int ilo, const int ihi, float* H, const int ldH,
- float* wr, float* wi, float* Z, const int ldz, float* work,
- const int* lwork){
- int info;
+ int hseqr_backend(const char* job, const char* compz, const integer_t* n,
+ const integer_t ilo, const integer_t ihi, float* H, const integer_t ldH,
+ float* wr, float* wi, float* Z, const integer_t ldz, float* work,
+ const integer_t* lwork){
+ integer_t info;
LAPACK_SHSEQR(job, compz, n, &ilo, &ihi, H, &ldH, wr, wi,
Z, &ldz, work, lwork, &info);
return info;
@@ -106,11 +106,11 @@
// double
inline
- int hseqr_backend(const char* job, const char* compz, const int* n,
- const int ilo, const int ihi, double* H, const int ldH,
- double* wr, double* wi, double* Z, const int ldz, double* work,
- const int* lwork){
- int info;
+ int hseqr_backend(const char* job, const char* compz, const integer_t* n,
+ const integer_t ilo, const integer_t ihi, double* H, const integer_t ldH,
+ double* wr, double* wi, double* Z, const integer_t ldz, double* work,
+ const integer_t* lwork){
+ integer_t info;
LAPACK_DHSEQR(job, compz, n, &ilo, &ihi, H, &ldH, wr, wi,
Z, &ldz, work, lwork, &info);
return info;
@@ -118,11 +118,11 @@
// complex_f
inline
- int hseqr_backend(const char* job, const char* compz, int* n,
- const int ilo, const int ihi, traits::complex_f* H, const int ldH,
- traits::complex_f* w, traits::complex_f* Z, int ldz,
- traits::complex_f* work, const int* lwork){
- int info;
+ int hseqr_backend(const char* job, const char* compz, integer_t* n,
+ const integer_t ilo, const integer_t ihi, traits::complex_f* H, const integer_t ldH,
+ traits::complex_f* w, traits::complex_f* Z, integer_t ldz,
+ traits::complex_f* work, const integer_t* lwork){
+ integer_t info;
LAPACK_CHSEQR(job, compz, n, &ilo, &ihi,
traits::complex_ptr(H), &ldH,
traits::complex_ptr(w),
@@ -133,11 +133,11 @@
// complex_d
inline
- int hseqr_backend(const char* job, const char* compz, int* n,
- const int ilo, const int ihi, traits::complex_d* H, const int ldH,
- traits::complex_d* w, traits::complex_d* Z, int ldz,
- traits::complex_d* work, const int* lwork){
- int info;
+ int hseqr_backend(const char* job, const char* compz, integer_t* n,
+ const integer_t ilo, const integer_t ihi, traits::complex_d* H, const integer_t ldH,
+ traits::complex_d* w, traits::complex_d* Z, integer_t ldz,
+ traits::complex_d* work, const integer_t* lwork){
+ integer_t info;
LAPACK_ZHSEQR(job, compz, n, &ilo, &ihi,
traits::complex_ptr(H), &ldH,
traits::complex_ptr(w),
@@ -154,13 +154,13 @@
template < typename A, typename W, typename V>
int operator() ( const char job, const char compz, A& H, W& w, V& Z ){
- int n = traits::matrix_size1(H);
+ integer_t n = traits::matrix_size1(H);
typedef typename A::value_type value_type;
traits::detail::array<value_type> wr(n);
traits::detail::array<value_type> wi(n);
// workspace query
- int lwork = -1;
+ integer_t lwork = -1;
value_type work_temp;
int result = detail::hseqr_backend(&job, &compz, &n, 1, n,
traits::matrix_storage(H),
@@ -172,7 +172,7 @@
if( result !=0 ) return result;
- lwork = (int) work_temp;
+ lwork = traits::detail::to_int(work_temp);
traits::detail::array<value_type> work(lwork);
result = detail::hseqr_backend(&job, &compz, &n, 1, n,
traits::matrix_storage(H),
@@ -194,11 +194,11 @@
template < typename A, typename W, typename V>
int operator() ( const char job, const char compz, A& H, W& w, V& Z ){
- int n = traits::matrix_size1(H);
+ integer_t n = traits::matrix_size1(H);
typedef typename A::value_type value_type;
// workspace query
- int lwork = -1;
+ integer_t lwork = -1;
value_type work_temp;
int result = detail::hseqr_backend(&job, &compz, &n, 1, n,
traits::matrix_storage(H),
@@ -209,7 +209,7 @@
if( result !=0 ) return result;
- lwork = (int) std::real(work_temp);
+ lwork = traits::detail::to_int(work_temp);
traits::detail::array<value_type> work(lwork);
result = detail::hseqr_backend(&job, &compz, &n, 1, n,
traits::matrix_storage(H),
@@ -249,7 +249,7 @@
#endif
#ifndef NDEBUG
- int const n = traits::matrix_size1(H);
+ std::ptrdiff_t const n = traits::matrix_size1(H);
#endif
typedef typename A::value_type value_type;
@@ -274,7 +274,7 @@
#endif
#ifndef NDEBUG
- int const n = traits::matrix_size1(H);
+ std::ptrdiff_t const n = traits::matrix_size1(H);
#endif
typedef typename A::value_type value_type;
Modified: sandbox/boost/numeric/bindings/lapack/ilaenv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/ilaenv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/ilaenv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -26,9 +26,9 @@
*/
inline
- int ilaenv (int const ispec, const char* name, const char* opts,
- int const n1 = -1, int const n2 = -1,
- int const n3 = -1, int const n4 = -1)
+ integer_t ilaenv (integer_t const ispec, const char* name, const char* opts,
+ integer_t const n1 = -1, integer_t const n2 = -1,
+ integer_t const n3 = -1, integer_t const n4 = -1)
{
return ::LAPACK_ILAENV (&ispec, name, opts, &n1, &n2, &n3, &n4,
std::strlen (name), std::strlen (opts));
Modified: sandbox/boost/numeric/bindings/lapack/lapack.h
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/lapack.h (original)
+++ sandbox/boost/numeric/bindings/lapack/lapack.h 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -29,583 +29,583 @@
/* general */
- void LAPACK_SGESV (int const* n, int const* nrhs,
- float* a, int const* lda, int* ipiv,
- float* b, int const* ldb, int* info);
- void LAPACK_DGESV (int const* n, int const* nrhs,
- double* a, int const* lda, int* ipiv,
- double* b, int const* ldb, int* info);
- void LAPACK_CGESV (int const* n, int const* nrhs,
- fcomplex_t* a, int const* lda, int* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZGESV (int const* n, int const* nrhs,
- dcomplex_t* a, int const* lda, int* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SGETRF (int const* n, int const* nrhs,
- float* a, int const* lda, int* ipiv, int* info);
- void LAPACK_DGETRF (int const* n, int const* nrhs,
- double* a, int const* lda, int* ipiv, int* info);
- void LAPACK_CGETRF (int const* n, int const* nrhs,
- fcomplex_t* a, int const* lda,
- int* ipiv, int* info);
- void LAPACK_ZGETRF (int const* n, int const* nrhs,
- dcomplex_t* a, int const* lda,
- int* ipiv, int* info);
-
- void LAPACK_SGETRS (char const* trans, int const* n, int const* nrhs,
- float const* a, int const* lda, int const* ipiv,
- float* b, int const* ldb, int* info);
- void LAPACK_DGETRS (char const* trans, int const* n, int const* nrhs,
- double const* a, int const* lda, int const* ipiv,
- double* b, int const* ldb, int* info);
- void LAPACK_CGETRS (char const* trans, int const* n, int const* nrhs,
- fcomplex_t const* a, int const* lda, int const* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZGETRS (char const* trans, int const* n, int const* nrhs,
- dcomplex_t const* a, int const* lda, int const* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SGETRI (int const* n, float* a, int const* lda, int const* ipiv,
- float* work, int const* lwork, int* info);
- void LAPACK_DGETRI (int const* n, double* a, int const* lda, int const* ipiv,
- double* work, int const* lwork, int* info);
- void LAPACK_CGETRI (int const* n, fcomplex_t* a, int const* lda, int const* ipiv,
- fcomplex_t* work, int const* lwork, int* info);
- void LAPACK_ZGETRI (int const* n, dcomplex_t* a, int const* lda, int const* ipiv,
- dcomplex_t* work, int const* lwork, int* info);
+ void LAPACK_SGESV (integer_t const* n, integer_t const* nrhs,
+ float* a, integer_t const* lda, integer_t* ipiv,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DGESV (integer_t const* n, integer_t const* nrhs,
+ double* a, integer_t const* lda, integer_t* ipiv,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CGESV (integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZGESV (integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SGETRF (integer_t const* n, integer_t const* nrhs,
+ float* a, integer_t const* lda, integer_t* ipiv, integer_t* info);
+ void LAPACK_DGETRF (integer_t const* n, integer_t const* nrhs,
+ double* a, integer_t const* lda, integer_t* ipiv, integer_t* info);
+ void LAPACK_CGETRF (integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* a, integer_t const* lda,
+ integer_t* ipiv, integer_t* info);
+ void LAPACK_ZGETRF (integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* a, integer_t const* lda,
+ integer_t* ipiv, integer_t* info);
+
+ void LAPACK_SGETRS (char const* trans, integer_t const* n, integer_t const* nrhs,
+ float const* a, integer_t const* lda, integer_t const* ipiv,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DGETRS (char const* trans, integer_t const* n, integer_t const* nrhs,
+ double const* a, integer_t const* lda, integer_t const* ipiv,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CGETRS (char const* trans, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t const* a, integer_t const* lda, integer_t const* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZGETRS (char const* trans, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t const* a, integer_t const* lda, integer_t const* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SGETRI (integer_t const* n, float* a, integer_t const* lda, integer_t const* ipiv,
+ float* work, integer_t const* lwork, integer_t* info);
+ void LAPACK_DGETRI (integer_t const* n, double* a, integer_t const* lda, integer_t const* ipiv,
+ double* work, integer_t const* lwork, integer_t* info);
+ void LAPACK_CGETRI (integer_t const* n, fcomplex_t* a, integer_t const* lda, integer_t const* ipiv,
+ fcomplex_t* work, integer_t const* lwork, integer_t* info);
+ void LAPACK_ZGETRI (integer_t const* n, dcomplex_t* a, integer_t const* lda, integer_t const* ipiv,
+ dcomplex_t* work, integer_t const* lwork, integer_t* info);
/* symmetric/Hermitian positive definite */
- void LAPACK_SPOSV (char const* uplo, int const* n, int const* nrhs,
- float* a, int const* lda,
- float* b, int const* ldb, int* info);
- void LAPACK_DPOSV (char const* uplo, int const* n, int const* nrhs,
- double* a, int const* lda,
- double* b, int const* ldb, int* info);
- void LAPACK_CPOSV (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t* a, int const* lda,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZPOSV (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t* a, int const* lda,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SPOTRF (char const* uplo, int const* n,
- float* a, int const* lda, int* info);
- void LAPACK_DPOTRF (char const* uplo, int const* n,
- double* a, int const* lda, int* info);
- void LAPACK_CPOTRF (char const* uplo, int const* n,
- fcomplex_t* a, int const* lda, int* info);
- void LAPACK_ZPOTRF (char const* uplo, int const* n,
- dcomplex_t* a, int const* lda, int* info);
-
- void LAPACK_SPOTRS (char const* uplo, int const* n, int const* nrhs,
- float const* a, int const* lda,
- float* b, int const* ldb, int* info);
- void LAPACK_DPOTRS (char const* uplo, int const* n, int const* nrhs,
- double const* a, int const* lda,
- double* b, int const* ldb, int* info);
- void LAPACK_CPOTRS (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t const* a, int const* lda,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZPOTRS (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t const* a, int const* lda,
- dcomplex_t* b, int const* ldb, int* info);
+ void LAPACK_SPOSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float* a, integer_t const* lda,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DPOSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double* a, integer_t const* lda,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CPOSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* a, integer_t const* lda,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZPOSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* a, integer_t const* lda,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SPOTRF (char const* uplo, integer_t const* n,
+ float* a, integer_t const* lda, integer_t* info);
+ void LAPACK_DPOTRF (char const* uplo, integer_t const* n,
+ double* a, integer_t const* lda, integer_t* info);
+ void LAPACK_CPOTRF (char const* uplo, integer_t const* n,
+ fcomplex_t* a, integer_t const* lda, integer_t* info);
+ void LAPACK_ZPOTRF (char const* uplo, integer_t const* n,
+ dcomplex_t* a, integer_t const* lda, integer_t* info);
+
+ void LAPACK_SPOTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float const* a, integer_t const* lda,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DPOTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double const* a, integer_t const* lda,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CPOTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t const* a, integer_t const* lda,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZPOTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t const* a, integer_t const* lda,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
/* symmetric/Hermitian positive definite in packed storage */
- void LAPACK_SPPSV (char const* uplo, int const* n, int const* nrhs,
- float* ap, float* b, int const* ldb, int* info);
- void LAPACK_DPPSV (char const* uplo, int const* n, int const* nrhs,
- double* ap, double* b, int const* ldb, int* info);
- void LAPACK_CPPSV (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t* ap, fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZPPSV (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t* ap, dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SPPTRF (char const* uplo, int const* n, float* ap, int* info);
- void LAPACK_DPPTRF (char const* uplo, int const* n, double* ap, int* info);
- void LAPACK_CPPTRF (char const* uplo, int const* n,
- fcomplex_t* ap, int* info);
- void LAPACK_ZPPTRF (char const* uplo, int const* n,
- dcomplex_t* ap, int* info);
-
- void LAPACK_SPPTRS (char const* uplo, int const* n, int const* nrhs,
- float const* ap, float* b, int const* ldb, int* info);
- void LAPACK_DPPTRS (char const* uplo, int const* n, int const* nrhs,
- double const* ap, double* b, int const* ldb, int* info);
- void LAPACK_CPPTRS (char const* uplo, int const* n, int const* nrhs,
+ void LAPACK_SPPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float* ap, float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DPPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double* ap, double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CPPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* ap, fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZPPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* ap, dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SPPTRF (char const* uplo, integer_t const* n, float* ap, integer_t* info);
+ void LAPACK_DPPTRF (char const* uplo, integer_t const* n, double* ap, integer_t* info);
+ void LAPACK_CPPTRF (char const* uplo, integer_t const* n,
+ fcomplex_t* ap, integer_t* info);
+ void LAPACK_ZPPTRF (char const* uplo, integer_t const* n,
+ dcomplex_t* ap, integer_t* info);
+
+ void LAPACK_SPPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float const* ap, float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DPPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double const* ap, double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CPPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
fcomplex_t const* ap,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZPPTRS (char const* uplo, int const* n, int const* nrhs,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZPPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
dcomplex_t const* ap,
- dcomplex_t* b, int const* ldb, int* info);
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
- void LAPACK_SPPTRI (char const* uplo, int const* n, float* ap, int* info);
- void LAPACK_DPPTRI (char const* uplo, int const* n, double* ap, int* info);
- void LAPACK_CPPTRI (char const* uplo, int const* n,
- fcomplex_t* ap, int* info);
- void LAPACK_ZPPTRI (char const* uplo, int const* n,
- dcomplex_t* ap, int* info);
+ void LAPACK_SPPTRI (char const* uplo, integer_t const* n, float* ap, integer_t* info);
+ void LAPACK_DPPTRI (char const* uplo, integer_t const* n, double* ap, integer_t* info);
+ void LAPACK_CPPTRI (char const* uplo, integer_t const* n,
+ fcomplex_t* ap, integer_t* info);
+ void LAPACK_ZPPTRI (char const* uplo, integer_t const* n,
+ dcomplex_t* ap, integer_t* info);
/* symmetric/Hermitian positive definite tridiagonal */
- void LAPACK_SPTSV (int const* N, int const* NRHS, float* D, float* E
- , float* B, int const* LDB, int* INFO
+ void LAPACK_SPTSV (integer_t const* N, integer_t const* NRHS, float* D, float* E
+ , float* B, integer_t const* LDB, integer_t* INFO
);
- void LAPACK_DPTSV (int const* N, int const* NRHS, double* D, double* E
- , double* B, int const* LDB, int* INFO
+ void LAPACK_DPTSV (integer_t const* N, integer_t const* NRHS, double* D, double* E
+ , double* B, integer_t const* LDB, integer_t* INFO
);
- void LAPACK_CPTSV (int const* N, int const* NRHS, float* D, fcomplex_t* E
- , fcomplex_t* B, int const* LDB, int* INFO
+ void LAPACK_CPTSV (integer_t const* N, integer_t const* NRHS, float* D, fcomplex_t* E
+ , fcomplex_t* B, integer_t const* LDB, integer_t* INFO
);
- void LAPACK_ZPTSV (int const* N, int const* NRHS, double* D, dcomplex_t* E
- , dcomplex_t* B, int const* LDB, int* INFO
+ void LAPACK_ZPTSV (integer_t const* N, integer_t const* NRHS, double* D, dcomplex_t* E
+ , dcomplex_t* B, integer_t const* LDB, integer_t* INFO
);
- void LAPACK_SPTTRF ( int const* n, float* d, float* e, int* info);
- void LAPACK_DPTTRF ( int const* n, double* d, double* e, int* info);
- void LAPACK_CPTTRF ( int const* n, float* d, fcomplex_t* e, int* info);
- void LAPACK_ZPTTRF ( int const* n, double* d, dcomplex_t* e, int* info);
+ void LAPACK_SPTTRF ( integer_t const* n, float* d, float* e, integer_t* info);
+ void LAPACK_DPTTRF ( integer_t const* n, double* d, double* e, integer_t* info);
+ void LAPACK_CPTTRF ( integer_t const* n, float* d, fcomplex_t* e, integer_t* info);
+ void LAPACK_ZPTTRF ( integer_t const* n, double* d, dcomplex_t* e, integer_t* info);
- void LAPACK_SPTTRS ( int const* n, int const* nrhs,
+ void LAPACK_SPTTRS ( integer_t const* n, integer_t const* nrhs,
float const* d, float const* e,
- float* b, int const* ldb, int* info);
- void LAPACK_DPTTRS ( int const* n, int const* nrhs,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DPTTRS ( integer_t const* n, integer_t const* nrhs,
double const* d, double const* e,
- double* b, int const* ldb, int* info);
- void LAPACK_CPTTRS (char const* uplo, int const* n, int const* nrhs,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CPTTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
float const* d, fcomplex_t const* e,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZPTTRS (char const* uplo, int const* n, int const* nrhs,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZPTTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
double const* d, dcomplex_t const* e,
- dcomplex_t* b, int const* ldb, int* info);
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
/* symmetric/Hermitian indefinite and complex symmetric */
- void LAPACK_SSYSV (char const* uplo, int const* n, int const* nrhs,
- float* a, int const* lda, int* ipiv,
- float* b, int const* ldb,
- float* w, int const* lw, int* info);
- void LAPACK_DSYSV (char const* uplo, int const* n, int const* nrhs,
- double* a, int const* lda, int* ipiv,
- double* b, int const* ldb,
- double* w, int const* lw, int* info);
- void LAPACK_CSYSV (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t* a, int const* lda, int* ipiv,
- fcomplex_t* b, int const* ldb,
- fcomplex_t* w, int const* lw, int* info);
- void LAPACK_ZSYSV (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t* a, int const* lda, int* ipiv,
- dcomplex_t* b, int const* ldb,
- dcomplex_t* w, int const* lw, int* info);
-
- void LAPACK_CHESV (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t* a, int const* lda, int* ipiv,
- fcomplex_t* b, int const* ldb,
- fcomplex_t* w, int const* lw, int* info);
- void LAPACK_ZHESV (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t* a, int const* lda, int* ipiv,
- dcomplex_t* b, int const* ldb,
- dcomplex_t* w, int const* lw, int* info);
-
- void LAPACK_SSYTRF (char const* uplo, int const* n,
- float* a, int const* lda, int* ipiv,
- float* w, int const* lw, int* info);
- void LAPACK_DSYTRF (char const* uplo, int const* n,
- double* a, int const* lda, int* ipiv,
- double* w, int const* lw, int* info);
- void LAPACK_CSYTRF (char const* uplo, int const* n,
- fcomplex_t* a, int const* lda, int* ipiv,
- fcomplex_t* w, int const* lw, int* info);
- void LAPACK_ZSYTRF (char const* uplo, int const* n,
- dcomplex_t* a, int const* lda, int* ipiv,
- dcomplex_t* w, int const* lw, int* info);
-
- void LAPACK_CHETRF (char const* uplo, int const* n,
- fcomplex_t* a, int const* lda, int* ipiv,
- fcomplex_t* w, int const* lw, int* info);
- void LAPACK_ZHETRF (char const* uplo, int const* n,
- dcomplex_t* a, int const* lda, int* ipiv,
- dcomplex_t* w, int const* lw, int* info);
-
- void LAPACK_SSYTRS (char const* uplo, int const* n, int const* nrhs,
- float const* a, int const* lda, int const* ipiv,
- float* b, int const* ldb, int* info);
- void LAPACK_DSYTRS (char const* uplo, int const* n, int const* nrhs,
- double const* a, int const* lda, int const* ipiv,
- double* b, int const* ldb, int* info);
- void LAPACK_CSYTRS (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t const* a, int const* lda, int const* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZSYTRS (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t const* a, int const* lda, int const* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SSYTRI (char const* uplo, int const* n, float* a,
- int const* lda, int const* ipiv, float* work,
- int* info);
- void LAPACK_DSYTRI (char const* uplo, int const* n, double* a,
- int const* lda, int const* ipiv, double* work,
- int* info);
- void LAPACK_CSYTRI (char const* uplo, int const* n, fcomplex_t* a,
- int const* lda, int const* ipiv, fcomplex_t* work,
- int* info);
- void LAPACK_ZSYTRI (char const* uplo, int const* n, dcomplex_t* a,
- int const* lda, int const* ipiv, dcomplex_t* work,
- int* info);
+ void LAPACK_SSYSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float* a, integer_t const* lda, integer_t* ipiv,
+ float* b, integer_t const* ldb,
+ float* w, integer_t const* lw, integer_t* info);
+ void LAPACK_DSYSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double* a, integer_t const* lda, integer_t* ipiv,
+ double* b, integer_t const* ldb,
+ double* w, integer_t const* lw, integer_t* info);
+ void LAPACK_CSYSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ fcomplex_t* b, integer_t const* ldb,
+ fcomplex_t* w, integer_t const* lw, integer_t* info);
+ void LAPACK_ZSYSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ dcomplex_t* b, integer_t const* ldb,
+ dcomplex_t* w, integer_t const* lw, integer_t* info);
+
+ void LAPACK_CHESV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ fcomplex_t* b, integer_t const* ldb,
+ fcomplex_t* w, integer_t const* lw, integer_t* info);
+ void LAPACK_ZHESV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ dcomplex_t* b, integer_t const* ldb,
+ dcomplex_t* w, integer_t const* lw, integer_t* info);
+
+ void LAPACK_SSYTRF (char const* uplo, integer_t const* n,
+ float* a, integer_t const* lda, integer_t* ipiv,
+ float* w, integer_t const* lw, integer_t* info);
+ void LAPACK_DSYTRF (char const* uplo, integer_t const* n,
+ double* a, integer_t const* lda, integer_t* ipiv,
+ double* w, integer_t const* lw, integer_t* info);
+ void LAPACK_CSYTRF (char const* uplo, integer_t const* n,
+ fcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ fcomplex_t* w, integer_t const* lw, integer_t* info);
+ void LAPACK_ZSYTRF (char const* uplo, integer_t const* n,
+ dcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ dcomplex_t* w, integer_t const* lw, integer_t* info);
+
+ void LAPACK_CHETRF (char const* uplo, integer_t const* n,
+ fcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ fcomplex_t* w, integer_t const* lw, integer_t* info);
+ void LAPACK_ZHETRF (char const* uplo, integer_t const* n,
+ dcomplex_t* a, integer_t const* lda, integer_t* ipiv,
+ dcomplex_t* w, integer_t const* lw, integer_t* info);
+
+ void LAPACK_SSYTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float const* a, integer_t const* lda, integer_t const* ipiv,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DSYTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double const* a, integer_t const* lda, integer_t const* ipiv,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CSYTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t const* a, integer_t const* lda, integer_t const* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZSYTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t const* a, integer_t const* lda, integer_t const* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SSYTRI (char const* uplo, integer_t const* n, float* a,
+ integer_t const* lda, integer_t const* ipiv, float* work,
+ integer_t* info);
+ void LAPACK_DSYTRI (char const* uplo, integer_t const* n, double* a,
+ integer_t const* lda, integer_t const* ipiv, double* work,
+ integer_t* info);
+ void LAPACK_CSYTRI (char const* uplo, integer_t const* n, fcomplex_t* a,
+ integer_t const* lda, integer_t const* ipiv, fcomplex_t* work,
+ integer_t* info);
+ void LAPACK_ZSYTRI (char const* uplo, integer_t const* n, dcomplex_t* a,
+ integer_t const* lda, integer_t const* ipiv, dcomplex_t* work,
+ integer_t* info);
- void LAPACK_CHETRS (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t const* a, int const* lda, int const* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZHETRS (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t const* a, int const* lda, int const* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
+ void LAPACK_CHETRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t const* a, integer_t const* lda, integer_t const* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZHETRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t const* a, integer_t const* lda, integer_t const* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
/* symmetric/Hermitian indefinite and complex symmetric in packed storage */
- void LAPACK_SSPSV (char const* uplo, int const* n, int const* nrhs,
- float* ap, int* ipiv,
- float* b, int const* ldb, int* info);
- void LAPACK_DSPSV (char const* uplo, int const* n, int const* nrhs,
- double* ap, int* ipiv,
- double* b, int const* ldb, int* info);
- void LAPACK_CSPSV (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t* ap, int* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZSPSV (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t* ap, int* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_CHPSV (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t* ap, int* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZHPSV (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t* ap, int* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SSPTRF (char const* uplo, int const* n,
- float* ap, int* ipiv, int* info);
- void LAPACK_DSPTRF (char const* uplo, int const* n,
- double* ap, int* ipiv, int* info);
- void LAPACK_CSPTRF (char const* uplo, int const* n,
- fcomplex_t* ap, int* ipiv, int* info);
- void LAPACK_ZSPTRF (char const* uplo, int const* n,
- dcomplex_t* ap, int* ipiv, int* info);
-
- void LAPACK_CHPTRF (char const* uplo, int const* n,
- fcomplex_t* ap, int* ipiv, int* info);
- void LAPACK_ZHPTRF (char const* uplo, int const* n,
- dcomplex_t* ap, int* ipiv, int* info);
-
- void LAPACK_SSPTRS (char const* uplo, int const* n, int const* nrhs,
- float const* ap, int const* ipiv,
- float* b, int const* ldb, int* info);
- void LAPACK_DSPTRS (char const* uplo, int const* n, int const* nrhs,
- double const* ap, int const* ipiv,
- double* b, int const* ldb, int* info);
- void LAPACK_CSPTRS (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t const* ap, int const* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZSPTRS (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t const* ap, int const* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
-
- void LAPACK_SSPTRI (char const* uplo, int const* n, float const* ap,
- int const* ipiv, float* work, int* info);
- void LAPACK_DSPTRI (char const* uplo, int const* n, double const* ap,
- int const* ipiv, double* work, int* info);
- void LAPACK_CSPTRI (char const* uplo, int const* n, fcomplex_t const* ap,
- int const* ipiv, fcomplex_t* work, int* info);
- void LAPACK_ZSPTRI (char const* uplo, int const* n, dcomplex_t const* ap,
- int const* ipiv, dcomplex_t* work, int* info);
-
- void LAPACK_CHPTRS (char const* uplo, int const* n, int const* nrhs,
- fcomplex_t const* ap, int const* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZHPTRS (char const* uplo, int const* n, int const* nrhs,
- dcomplex_t const* ap, int const* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
+ void LAPACK_SSPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float* ap, integer_t* ipiv,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DSPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double* ap, integer_t* ipiv,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CSPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* ap, integer_t* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZSPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* ap, integer_t* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_CHPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t* ap, integer_t* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZHPSV (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t* ap, integer_t* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SSPTRF (char const* uplo, integer_t const* n,
+ float* ap, integer_t* ipiv, integer_t* info);
+ void LAPACK_DSPTRF (char const* uplo, integer_t const* n,
+ double* ap, integer_t* ipiv, integer_t* info);
+ void LAPACK_CSPTRF (char const* uplo, integer_t const* n,
+ fcomplex_t* ap, integer_t* ipiv, integer_t* info);
+ void LAPACK_ZSPTRF (char const* uplo, integer_t const* n,
+ dcomplex_t* ap, integer_t* ipiv, integer_t* info);
+
+ void LAPACK_CHPTRF (char const* uplo, integer_t const* n,
+ fcomplex_t* ap, integer_t* ipiv, integer_t* info);
+ void LAPACK_ZHPTRF (char const* uplo, integer_t const* n,
+ dcomplex_t* ap, integer_t* ipiv, integer_t* info);
+
+ void LAPACK_SSPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ float const* ap, integer_t const* ipiv,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DSPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ double const* ap, integer_t const* ipiv,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CSPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t const* ap, integer_t const* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZSPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t const* ap, integer_t const* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
+
+ void LAPACK_SSPTRI (char const* uplo, integer_t const* n, float const* ap,
+ integer_t const* ipiv, float* work, integer_t* info);
+ void LAPACK_DSPTRI (char const* uplo, integer_t const* n, double const* ap,
+ integer_t const* ipiv, double* work, integer_t* info);
+ void LAPACK_CSPTRI (char const* uplo, integer_t const* n, fcomplex_t const* ap,
+ integer_t const* ipiv, fcomplex_t* work, integer_t* info);
+ void LAPACK_ZSPTRI (char const* uplo, integer_t const* n, dcomplex_t const* ap,
+ integer_t const* ipiv, dcomplex_t* work, integer_t* info);
+
+ void LAPACK_CHPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ fcomplex_t const* ap, integer_t const* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZHPTRS (char const* uplo, integer_t const* n, integer_t const* nrhs,
+ dcomplex_t const* ap, integer_t const* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
/* banded */
- void LAPACK_SGBTRF (int const* n, int const* m, int const* kl, int const* ku,
- float* ab, int const* ldab, int* ipiv, int* info);
- void LAPACK_DGBTRF (int const* n, int const* m, int const* kl, int const* ku,
- double* ab, int const* ldab, int* ipiv, int* info);
- void LAPACK_CGBTRF (int const* n, int const* m, int const* kl, int const* ku,
- fcomplex_t* ab, int const* ldab, int* ipiv, int* info);
- void LAPACK_ZGBTRF (int const* n, int const* m, int const* kl, int const* ku,
- dcomplex_t* ab, int const* ldab, int* ipiv, int* info);
-
- void LAPACK_SGBTRS (char const* trans, int const* n, int const* kl, int const* ku, int const* nrhs,
- float const* ab, int const* ldab, int const* ipiv,
- float* b, int const* ldb, int* info);
- void LAPACK_DGBTRS (char const* trans, int const* n, int const* kl, int const* ku, int const* nrhs,
- double const* ab, int const* ldab, int const* ipiv,
- double* b, int const* ldb, int* info);
- void LAPACK_CGBTRS (char const* trans, int const* n, int const* kl, int const* ku, int const* nrhs,
- fcomplex_t const* ab, int const* ldab, int const* ipiv,
- fcomplex_t* b, int const* ldb, int* info);
- void LAPACK_ZGBTRS (char const* trans, int const* n, int const* kl, int const* ku, int const* nrhs,
- dcomplex_t const* ab, int const* ldab, int const* ipiv,
- dcomplex_t* b, int const* ldb, int* info);
+ void LAPACK_SGBTRF (integer_t const* n, integer_t const* m, integer_t const* kl, integer_t const* ku,
+ float* ab, integer_t const* ldab, integer_t* ipiv, integer_t* info);
+ void LAPACK_DGBTRF (integer_t const* n, integer_t const* m, integer_t const* kl, integer_t const* ku,
+ double* ab, integer_t const* ldab, integer_t* ipiv, integer_t* info);
+ void LAPACK_CGBTRF (integer_t const* n, integer_t const* m, integer_t const* kl, integer_t const* ku,
+ fcomplex_t* ab, integer_t const* ldab, integer_t* ipiv, integer_t* info);
+ void LAPACK_ZGBTRF (integer_t const* n, integer_t const* m, integer_t const* kl, integer_t const* ku,
+ dcomplex_t* ab, integer_t const* ldab, integer_t* ipiv, integer_t* info);
+
+ void LAPACK_SGBTRS (char const* trans, integer_t const* n, integer_t const* kl, integer_t const* ku, integer_t const* nrhs,
+ float const* ab, integer_t const* ldab, integer_t const* ipiv,
+ float* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_DGBTRS (char const* trans, integer_t const* n, integer_t const* kl, integer_t const* ku, integer_t const* nrhs,
+ double const* ab, integer_t const* ldab, integer_t const* ipiv,
+ double* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_CGBTRS (char const* trans, integer_t const* n, integer_t const* kl, integer_t const* ku, integer_t const* nrhs,
+ fcomplex_t const* ab, integer_t const* ldab, integer_t const* ipiv,
+ fcomplex_t* b, integer_t const* ldb, integer_t* info);
+ void LAPACK_ZGBTRS (char const* trans, integer_t const* n, integer_t const* kl, integer_t const* ku, integer_t const* nrhs,
+ dcomplex_t const* ab, integer_t const* ldab, integer_t const* ipiv,
+ dcomplex_t* b, integer_t const* ldb, integer_t* info);
/**********************************************************************/
/* eigenproblems */
/**********************************************************************/
- void LAPACK_SGEES (const char* jobvs, const char* sort, logical_t* select, const int* n,
- float* a, const int * lda, const int* sdim, float* wr, float* wi,
- float* vs, const int * ldvs, float* work, const int * lwork,
- bool* bwork, int* info);
-
- void LAPACK_DGEES (const char* jobvs, const char* sort, logical_t* select, const int* n,
- double* a, const int * lda, const int* sdim, double* wr, double* wi,
- double* vs, const int * ldvs, double* work, const int * lwork,
- bool* bwork, int* info);
-
- void LAPACK_CGEES( const char* jobvs, const char* sort, logical_t* select, const int *n,
- fcomplex_t* a, const int * lda, int * sdim, fcomplex_t* w, fcomplex_t* vs,
- const int * ldvs, fcomplex_t* work, const int * lwork, float* rwork,
- bool* bwork, int* info );
-
- void LAPACK_ZGEES( const char* jobvs, const char* sort, const logical_t* select, const int *n,
- dcomplex_t* a, const int * lda, int * sdim, dcomplex_t* w, dcomplex_t* vs,
- const int * ldvs, dcomplex_t* work, const int * lwork, double* rwork,
- bool* bwork, int* info );
-
-
- void LAPACK_SGEEV( const char* jobvl, const char* jobvr, const int* n, float* a,
- const int* lda, float* wr, float* wi, float* vl, const int* ldvl,
- float* vr, const int* ldvr, float* work, const int* lwork, int* info );
-
- void LAPACK_DGEEV( const char* jobvl, const char* jobvr, const int* n, double* a,
- const int* lda, double* wr, double* wi, double* vl, const int* ldvl,
- double* vr, const int* ldvr, double* work, const int* lwork, int* info );
-
- void LAPACK_CGEEV( const char* jobvl, const char* jobvr, const int* n, fcomplex_t* a,
- const int* lda, fcomplex_t* w, fcomplex_t* vl, const int* ldvl,
- fcomplex_t* vr, const int* ldvr, fcomplex_t* work, const int* lwork,
- float* rwork, int* info );
-
- void LAPACK_ZGEEV( const char* jobvl, const char* jobvr, const int* n, dcomplex_t* a,
- const int* lda, dcomplex_t* w, dcomplex_t* vl, const int* ldvl,
- dcomplex_t* vr, const int* ldvr, dcomplex_t* work, const int* lwork,
- double* rwork, int* info );
-
-
- void LAPACK_SSYEV( const char* jobz, const char* uplo, const int *n,
- float* a, const int * lda, float* w,
- float* work, const int * lwork, int* info );
-
- void LAPACK_DSYEV( const char* jobz, const char* uplo, const int *n,
- double* a, const int * lda, double* w,
- double* work, const int * lwork, int* info );
-
- void LAPACK_CHEEV( const char* jobz, const char* uplo, const int *n,
- fcomplex_t* a, const int * lda, float* w,
- fcomplex_t* work, const int * lwork, float* rwork,
- int* info );
-
- void LAPACK_ZHEEV( const char* jobz, const char* uplo, const int *n,
- dcomplex_t* a, const int * lda, double* w,
- dcomplex_t* work, const int * lwork, double* rwork,
- int* info );
-
-
- void LAPACK_SSYEVD( const char* jobz, const char* uplo, const int* n,
- float* a, const int* lda, float* w,
- float* work, const int* lwork,
- int* iwork, const int* liwork, int* info);
-
- void LAPACK_DSYEVD( const char* jobz, const char* uplo, const int* n,
- double* a, const int* lda, double* w,
- double* work, const int* lwork,
- int* iwork, const int* liwork, int* info);
-
- void LAPACK_CHEEVD( const char* jobz, const char* uplo, const int* n,
- fcomplex_t* a, const int* lda, float* w,
- fcomplex_t* work, const int* lwork, float* rwork, const int* lrwork,
- int* iwork, const int* liwork, int* info);
-
- void LAPACK_ZHEEVD( const char* jobz, const char* uplo, const int* n,
- dcomplex_t* a, const int* lda, double* w,
- dcomplex_t* work, const int* lwork, double* rwork, const int* lrwork,
- int* iwork, const int* liwork, int* info);
-
-
- void LAPACK_SSYEVX( const char* jobz, const char* range, const char* uplo, const int* n,
- float* a, const int* lda, const float* vl, const float* vu, const int* il, const int* iu,
- const float* abstol, int* m, float* w, float* z, const int* ldz,
- float* work, const int* lwork,
- int* iwork, int* ifail, int* info);
-
- void LAPACK_DSYEVX( const char* jobz, const char* range, const char* uplo, const int* n,
- double* a, const int* lda, const double* vl, const double* vu, const int* il, const int* iu,
- const double* abstol, int* m, double* w, double* z, const int* ldz,
- double* work, const int* lwork,
- int* iwork, int* ifail, int* info);
-
- void LAPACK_CHEEVX( const char* jobz, const char* range, const char* uplo, const int* n,
- fcomplex_t* a, const int* lda, const float* vl, const float* vu, const int* il, const int* iu,
- const float* abstol, int* m, float* w, fcomplex_t* z, const int* ldz,
- fcomplex_t* work, const int* lwork, float* rwork,
- int* iwork, int* ifail, int* info);
-
- void LAPACK_ZHEEVX( const char* jobz, const char* range, const char* uplo, const int* n,
- dcomplex_t* a, const int* lda, const double* vl, const double* vu, const int* il, const int* iu,
- const double* abstol, int* m, double* w, dcomplex_t* z, const int* ldz,
- dcomplex_t* work, const int* lwork, double* rwork,
- int* iwork, int* ifail, int* info);
-
-
- void LAPACK_CTREVC( const char* side, const char* howmny, const logical_t* select, const int *n,
- fcomplex_t* t, const int * ldt, fcomplex_t* vl, const int* ldvl,
- fcomplex_t* vr, const int * ldvr, const int * nm, int* m, fcomplex_t* work,
- float* rwork, int* info );
-
- void LAPACK_ZTREVC( const char* side, const char* howmny, const logical_t* select, const int *n,
- dcomplex_t* t, const int * ldt, dcomplex_t* vl, const int* ldvl,
- dcomplex_t* vr, const int * ldvr, const int * nm, int* m, dcomplex_t* work,
- double* rwork, int* info );
-
- void LAPACK_STREVC( const char* side, const char* howmny, const logical_t* select, const int *n,
- float* t, const int * ldt, float* vl, const int* ldvl,
- float* vr, const int * ldvr, const int * nm, int* m, float* work,
- int* info );
-
- void LAPACK_DTREVC( const char* side, const char* howmny, const logical_t* select, const int *n,
- double* t, const int * ldt, double* vl, const int* ldvl,
- double* vr, const int * ldvr, const int * nm, int* m, double* work,
- int* info );
-
-
- void LAPACK_STREXC( const char* compq, const int *n,
- float* t, const int * ldt, float* q, const int* ldq,
- int* ifst, const int * ilst, float* work, int* info );
-
- void LAPACK_DTREXC( const char* compq, const int *n,
- double* t, const int * ldt, double* q, const int* ldq,
- int* ifst, const int * ilst, double* work, int* info );
-
- void LAPACK_CTREXC( const char* compq, const int *n,
- fcomplex_t* t, const int * ldt, fcomplex_t* q, const int* ldq,
- int* ifst, const int * ilst, int* info );
-
- void LAPACK_ZTREXC( const char* compq, const int *n,
- dcomplex_t* t, const int * ldt, dcomplex_t* q, const int* ldq,
- int* ifst, const int * ilst, int* info );
+ void LAPACK_SGEES (const char* jobvs, const char* sort, logical_t* select, const integer_t* n,
+ float* a, const integer_t * lda, const integer_t* sdim, float* wr, float* wi,
+ float* vs, const integer_t * ldvs, float* work, const integer_t * lwork,
+ bool* bwork, integer_t* info);
+
+ void LAPACK_DGEES (const char* jobvs, const char* sort, logical_t* select, const integer_t* n,
+ double* a, const integer_t * lda, const integer_t* sdim, double* wr, double* wi,
+ double* vs, const integer_t * ldvs, double* work, const integer_t * lwork,
+ bool* bwork, integer_t* info);
+
+ void LAPACK_CGEES( const char* jobvs, const char* sort, logical_t* select, const integer_t *n,
+ fcomplex_t* a, const integer_t * lda, integer_t * sdim, fcomplex_t* w, fcomplex_t* vs,
+ const integer_t * ldvs, fcomplex_t* work, const integer_t * lwork, float* rwork,
+ bool* bwork, integer_t* info );
+
+ void LAPACK_ZGEES( const char* jobvs, const char* sort, const logical_t* select, const integer_t *n,
+ dcomplex_t* a, const integer_t * lda, integer_t * sdim, dcomplex_t* w, dcomplex_t* vs,
+ const integer_t * ldvs, dcomplex_t* work, const integer_t * lwork, double* rwork,
+ bool* bwork, integer_t* info );
+
+
+ void LAPACK_SGEEV( const char* jobvl, const char* jobvr, const integer_t* n, float* a,
+ const integer_t* lda, float* wr, float* wi, float* vl, const integer_t* ldvl,
+ float* vr, const integer_t* ldvr, float* work, const integer_t* lwork, integer_t* info );
+
+ void LAPACK_DGEEV( const char* jobvl, const char* jobvr, const integer_t* n, double* a,
+ const integer_t* lda, double* wr, double* wi, double* vl, const integer_t* ldvl,
+ double* vr, const integer_t* ldvr, double* work, const integer_t* lwork, integer_t* info );
+
+ void LAPACK_CGEEV( const char* jobvl, const char* jobvr, const integer_t* n, fcomplex_t* a,
+ const integer_t* lda, fcomplex_t* w, fcomplex_t* vl, const integer_t* ldvl,
+ fcomplex_t* vr, const integer_t* ldvr, fcomplex_t* work, const integer_t* lwork,
+ float* rwork, integer_t* info );
+
+ void LAPACK_ZGEEV( const char* jobvl, const char* jobvr, const integer_t* n, dcomplex_t* a,
+ const integer_t* lda, dcomplex_t* w, dcomplex_t* vl, const integer_t* ldvl,
+ dcomplex_t* vr, const integer_t* ldvr, dcomplex_t* work, const integer_t* lwork,
+ double* rwork, integer_t* info );
+
+
+ void LAPACK_SSYEV( const char* jobz, const char* uplo, const integer_t *n,
+ float* a, const integer_t * lda, float* w,
+ float* work, const integer_t * lwork, integer_t* info );
+
+ void LAPACK_DSYEV( const char* jobz, const char* uplo, const integer_t *n,
+ double* a, const integer_t * lda, double* w,
+ double* work, const integer_t * lwork, integer_t* info );
+
+ void LAPACK_CHEEV( const char* jobz, const char* uplo, const integer_t *n,
+ fcomplex_t* a, const integer_t * lda, float* w,
+ fcomplex_t* work, const integer_t * lwork, float* rwork,
+ integer_t* info );
+
+ void LAPACK_ZHEEV( const char* jobz, const char* uplo, const integer_t *n,
+ dcomplex_t* a, const integer_t * lda, double* w,
+ dcomplex_t* work, const integer_t * lwork, double* rwork,
+ integer_t* info );
+
+
+ void LAPACK_SSYEVD( const char* jobz, const char* uplo, const integer_t* n,
+ float* a, const integer_t* lda, float* w,
+ float* work, const integer_t* lwork,
+ integer_t* iwork, const integer_t* liwork, integer_t* info);
+
+ void LAPACK_DSYEVD( const char* jobz, const char* uplo, const integer_t* n,
+ double* a, const integer_t* lda, double* w,
+ double* work, const integer_t* lwork,
+ integer_t* iwork, const integer_t* liwork, integer_t* info);
+
+ void LAPACK_CHEEVD( const char* jobz, const char* uplo, const integer_t* n,
+ fcomplex_t* a, const integer_t* lda, float* w,
+ fcomplex_t* work, const integer_t* lwork, float* rwork, const integer_t* lrwork,
+ integer_t* iwork, const integer_t* liwork, integer_t* info);
+
+ void LAPACK_ZHEEVD( const char* jobz, const char* uplo, const integer_t* n,
+ dcomplex_t* a, const integer_t* lda, double* w,
+ dcomplex_t* work, const integer_t* lwork, double* rwork, const integer_t* lrwork,
+ integer_t* iwork, const integer_t* liwork, integer_t* info);
+
+
+ void LAPACK_SSYEVX( const char* jobz, const char* range, const char* uplo, const integer_t* n,
+ float* a, const integer_t* lda, const float* vl, const float* vu, const integer_t* il, const integer_t* iu,
+ const float* abstol, integer_t* m, float* w, float* z, const integer_t* ldz,
+ float* work, const integer_t* lwork,
+ integer_t* iwork, integer_t* ifail, integer_t* info);
+
+ void LAPACK_DSYEVX( const char* jobz, const char* range, const char* uplo, const integer_t* n,
+ double* a, const integer_t* lda, const double* vl, const double* vu, const integer_t* il, const integer_t* iu,
+ const double* abstol, integer_t* m, double* w, double* z, const integer_t* ldz,
+ double* work, const integer_t* lwork,
+ integer_t* iwork, integer_t* ifail, integer_t* info);
+
+ void LAPACK_CHEEVX( const char* jobz, const char* range, const char* uplo, const integer_t* n,
+ fcomplex_t* a, const integer_t* lda, const float* vl, const float* vu, const integer_t* il, const integer_t* iu,
+ const float* abstol, integer_t* m, float* w, fcomplex_t* z, const integer_t* ldz,
+ fcomplex_t* work, const integer_t* lwork, float* rwork,
+ integer_t* iwork, integer_t* ifail, integer_t* info);
+
+ void LAPACK_ZHEEVX( const char* jobz, const char* range, const char* uplo, const integer_t* n,
+ dcomplex_t* a, const integer_t* lda, const double* vl, const double* vu, const integer_t* il, const integer_t* iu,
+ const double* abstol, integer_t* m, double* w, dcomplex_t* z, const integer_t* ldz,
+ dcomplex_t* work, const integer_t* lwork, double* rwork,
+ integer_t* iwork, integer_t* ifail, integer_t* info);
+
+
+ void LAPACK_CTREVC( const char* side, const char* howmny, const logical_t* select, const integer_t *n,
+ fcomplex_t* t, const integer_t * ldt, fcomplex_t* vl, const integer_t* ldvl,
+ fcomplex_t* vr, const integer_t * ldvr, const integer_t * nm, integer_t* m, fcomplex_t* work,
+ float* rwork, integer_t* info );
+
+ void LAPACK_ZTREVC( const char* side, const char* howmny, const logical_t* select, const integer_t *n,
+ dcomplex_t* t, const integer_t * ldt, dcomplex_t* vl, const integer_t* ldvl,
+ dcomplex_t* vr, const integer_t * ldvr, const integer_t * nm, integer_t* m, dcomplex_t* work,
+ double* rwork, integer_t* info );
+
+ void LAPACK_STREVC( const char* side, const char* howmny, const logical_t* select, const integer_t *n,
+ float* t, const integer_t * ldt, float* vl, const integer_t* ldvl,
+ float* vr, const integer_t * ldvr, const integer_t * nm, integer_t* m, float* work,
+ integer_t* info );
+
+ void LAPACK_DTREVC( const char* side, const char* howmny, const logical_t* select, const integer_t *n,
+ double* t, const integer_t * ldt, double* vl, const integer_t* ldvl,
+ double* vr, const integer_t * ldvr, const integer_t * nm, integer_t* m, double* work,
+ integer_t* info );
+
+
+ void LAPACK_STREXC( const char* compq, const integer_t *n,
+ float* t, const integer_t * ldt, float* q, const integer_t* ldq,
+ integer_t* ifst, const integer_t * ilst, float* work, integer_t* info );
+
+ void LAPACK_DTREXC( const char* compq, const integer_t *n,
+ double* t, const integer_t * ldt, double* q, const integer_t* ldq,
+ integer_t* ifst, const integer_t * ilst, double* work, integer_t* info );
+
+ void LAPACK_CTREXC( const char* compq, const integer_t *n,
+ fcomplex_t* t, const integer_t * ldt, fcomplex_t* q, const integer_t* ldq,
+ integer_t* ifst, const integer_t * ilst, integer_t* info );
+
+ void LAPACK_ZTREXC( const char* compq, const integer_t *n,
+ dcomplex_t* t, const integer_t * ldt, dcomplex_t* q, const integer_t* ldq,
+ integer_t* ifst, const integer_t * ilst, integer_t* info );
/* Hessenberg matrices */
- void LAPACK_SHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, float* H,
- const int* LDH, float* WR, float* WI, float* Z, int const* LDZ,
- float* WORK, const int* LWORK, int* INFO ) ;
-
- void LAPACK_CHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, fcomplex_t* H,
- const int* LDH, fcomplex_t* W, fcomplex_t* Z, int const* LDZ,
- fcomplex_t* WORK, const int* LWORK, int* INFO ) ;
-
- void LAPACK_DHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, double* H,
- const int* LDH, double* WR, double* WI, double* Z, int const* LDZ,
- double* WORK, const int* LWORK, int* INFO ) ;
-
- void LAPACK_ZHSEQR( const char* JOB, const char* COMPZ, const int* N, const int* ILO, const int* IHI, dcomplex_t* H,
- const int* LDH, dcomplex_t* W, dcomplex_t* Z, int const* LDZ,
- dcomplex_t* WORK, const int* LWORK, int* INFO ) ;
+ void LAPACK_SHSEQR( const char* JOB, const char* COMPZ, const integer_t* N, const integer_t* ILO, const integer_t* IHI, float* H,
+ const integer_t* LDH, float* WR, float* WI, float* Z, integer_t const* LDZ,
+ float* WORK, const integer_t* LWORK, integer_t* INFO ) ;
+
+ void LAPACK_CHSEQR( const char* JOB, const char* COMPZ, const integer_t* N, const integer_t* ILO, const integer_t* IHI, fcomplex_t* H,
+ const integer_t* LDH, fcomplex_t* W, fcomplex_t* Z, integer_t const* LDZ,
+ fcomplex_t* WORK, const integer_t* LWORK, integer_t* INFO ) ;
+
+ void LAPACK_DHSEQR( const char* JOB, const char* COMPZ, const integer_t* N, const integer_t* ILO, const integer_t* IHI, double* H,
+ const integer_t* LDH, double* WR, double* WI, double* Z, integer_t const* LDZ,
+ double* WORK, const integer_t* LWORK, integer_t* INFO ) ;
+
+ void LAPACK_ZHSEQR( const char* JOB, const char* COMPZ, const integer_t* N, const integer_t* ILO, const integer_t* IHI, dcomplex_t* H,
+ const integer_t* LDH, dcomplex_t* W, dcomplex_t* Z, integer_t const* LDZ,
+ dcomplex_t* WORK, const integer_t* LWORK, integer_t* INFO ) ;
/* Hermitian tridiagonal matrices */
- void LAPACK_SSTEQR( char const* compz, int const* n, float* d, float* E, float* z, int const* ldz, float* work, int* info ) ;
- void LAPACK_DSTEQR( char const* compz, int const* n, double* d, double* E, double* z, int const* ldz, double* work, int* info ) ;
+ void LAPACK_SSTEQR( char const* compz, integer_t const* n, float* d, float* E, float* z, integer_t const* ldz, float* work, integer_t* info ) ;
+ void LAPACK_DSTEQR( char const* compz, integer_t const* n, double* d, double* E, double* z, integer_t const* ldz, double* work, integer_t* info ) ;
/* Hermitian banded matrices */
- void LAPACK_SSBEV( char const* jobz, char const* uplo, int const* n,
- int const* kd, float* ab, int const* ldab, float* w,
- float* z, int const* ldz, float* work, int* info );
-
- void LAPACK_DSBEV( char const* jobz, char const* uplo, int const* n,
- int const* kd, double* ab, int const* ldab, double* w,
- double* z, int const* ldz, double* work, int* info );
-
- void LAPACK_CHBEV( char const* jobz, char const* uplo, int const* n,
- int const* kd, fcomplex_t* ab, int const* ldab, float* w,
- fcomplex_t* z, int const* ldz, fcomplex_t* work,
- float* rwork, int* info );
-
- void LAPACK_ZHBEV( char const* jobz, char const* uplo, int const* n,
- int const* kd, dcomplex_t* ab, int const* ldab, double* w,
- dcomplex_t* z, int const* ldz, dcomplex_t* work,
- double* rwork, int* info );
-
-
- void LAPACK_SSBEVX( char const* jobz, char const* range, char const* uplo, int const* n,
- int const* kd, float* ab, int const* ldab, float* q, int const* ldq,
- const float* vl, const float* vu, const int* il, const int* iu,
- const float* abstol, int* m,
- float* w, float* z, int const* ldz, float* work,
- int* iwork, int* ifail, int* info );
-
- void LAPACK_DSBEVX( char const* jobz, char const* range, char const* uplo, int const* n,
- int const* kd, double* ab, int const* ldab, double* q, int const* ldq,
- const double* vl, const double* vu, const int* il, const int* iu,
- const double* abstol, int* m,
- double* w, double* z, int const* ldz, double* work,
- int* iwork, int* ifail, int* info );
-
- void LAPACK_CHBEVX( char const* jobz, char const* range, char const* uplo, int const* n,
- int const* kd, fcomplex_t* ab, int const* ldab, fcomplex_t* q, int const* ldq,
- const float* vl, const float* vu, const int* il, const int* iu,
- const float* abstol, int* m,
- float* w, fcomplex_t* z, int const* ldz, fcomplex_t* work, float* rwork,
- int* iwork, int* ifail, int* info );
-
- void LAPACK_ZHBEVX( char const* jobz, char const* range, char const* uplo, int const* n,
- int const* kd, dcomplex_t* ab, int const* ldab, dcomplex_t* q, int const* ldq,
- const double* vl, const double* vu, const int* il, const int* iu,
- const double* abstol, int* m,
- double* w, dcomplex_t* z, int const* ldz, dcomplex_t* work, double* rwork,
- int* iwork, int* ifail, int* info );
+ void LAPACK_SSBEV( char const* jobz, char const* uplo, integer_t const* n,
+ integer_t const* kd, float* ab, integer_t const* ldab, float* w,
+ float* z, integer_t const* ldz, float* work, integer_t* info );
+
+ void LAPACK_DSBEV( char const* jobz, char const* uplo, integer_t const* n,
+ integer_t const* kd, double* ab, integer_t const* ldab, double* w,
+ double* z, integer_t const* ldz, double* work, integer_t* info );
+
+ void LAPACK_CHBEV( char const* jobz, char const* uplo, integer_t const* n,
+ integer_t const* kd, fcomplex_t* ab, integer_t const* ldab, float* w,
+ fcomplex_t* z, integer_t const* ldz, fcomplex_t* work,
+ float* rwork, integer_t* info );
+
+ void LAPACK_ZHBEV( char const* jobz, char const* uplo, integer_t const* n,
+ integer_t const* kd, dcomplex_t* ab, integer_t const* ldab, double* w,
+ dcomplex_t* z, integer_t const* ldz, dcomplex_t* work,
+ double* rwork, integer_t* info );
+
+
+ void LAPACK_SSBEVX( char const* jobz, char const* range, char const* uplo, integer_t const* n,
+ integer_t const* kd, float* ab, integer_t const* ldab, float* q, integer_t const* ldq,
+ const float* vl, const float* vu, const integer_t* il, const integer_t* iu,
+ const float* abstol, integer_t* m,
+ float* w, float* z, integer_t const* ldz, float* work,
+ integer_t* iwork, integer_t* ifail, integer_t* info );
+
+ void LAPACK_DSBEVX( char const* jobz, char const* range, char const* uplo, integer_t const* n,
+ integer_t const* kd, double* ab, integer_t const* ldab, double* q, integer_t const* ldq,
+ const double* vl, const double* vu, const integer_t* il, const integer_t* iu,
+ const double* abstol, integer_t* m,
+ double* w, double* z, integer_t const* ldz, double* work,
+ integer_t* iwork, integer_t* ifail, integer_t* info );
+
+ void LAPACK_CHBEVX( char const* jobz, char const* range, char const* uplo, integer_t const* n,
+ integer_t const* kd, fcomplex_t* ab, integer_t const* ldab, fcomplex_t* q, integer_t const* ldq,
+ const float* vl, const float* vu, const integer_t* il, const integer_t* iu,
+ const float* abstol, integer_t* m,
+ float* w, fcomplex_t* z, integer_t const* ldz, fcomplex_t* work, float* rwork,
+ integer_t* iwork, integer_t* ifail, integer_t* info );
+
+ void LAPACK_ZHBEVX( char const* jobz, char const* range, char const* uplo, integer_t const* n,
+ integer_t const* kd, dcomplex_t* ab, integer_t const* ldab, dcomplex_t* q, integer_t const* ldq,
+ const double* vl, const double* vu, const integer_t* il, const integer_t* iu,
+ const double* abstol, integer_t* m,
+ double* w, dcomplex_t* z, integer_t const* ldz, dcomplex_t* work, double* rwork,
+ integer_t* iwork, integer_t* ifail, integer_t* info );
/*********************************************************************/
/* Auxiliary routines for eigenvalue problems */
/*********************************************************************/
- void LAPACK_SSYTRD( char const* uplo, int const* n, float* a, int const* lda, float* d,
- float* e, float* tau, float* work, int const* lwork, int* INFO ) ;
+ void LAPACK_SSYTRD( char const* uplo, integer_t const* n, float* a, integer_t const* lda, float* d,
+ float* e, float* tau, float* work, integer_t const* lwork, integer_t* INFO ) ;
- void LAPACK_DSYTRD( char const* uplo, int const* n, double* a, int const* lda, double* d,
- double* e, double* tau, double* work, int const* lwork, int* INFO ) ;
+ void LAPACK_DSYTRD( char const* uplo, integer_t const* n, double* a, integer_t const* lda, double* d,
+ double* e, double* tau, double* work, integer_t const* lwork, integer_t* INFO ) ;
/**********************************************************************/
/* generalized eigenvalue / eigenvector */
/**********************************************************************/
- void LAPACK_SSYGV(int const* itype, char const* jobz, char const* uplo, int const* n,
- float* a, int const* lda, float* b, int const* ldb,
- float* w, float* work, int const* lwork, int* info);
-
- void LAPACK_DSYGV(int const* itype, char const* jobz, char const* uplo, int const* n,
- double* a, int const* lda, double* b, int const* ldb,
- double* w, double* work, int const* lwork, int* info);
-
- void LAPACK_CHEGV(int const* itype, char const* jobz, char const* uplo, int const* n,
- fcomplex_t* a, int const* lda, fcomplex_t* b, int const* ldb,
- float* w, fcomplex_t* work, int const* lwork, float* rwork, int* info);
-
- void LAPACK_ZHEGV(int const *itype, char const* jobz, char const *uplo, int const * n,
- dcomplex_t *a, int const *lda, dcomplex_t *b, int const *ldb,
- double *w, dcomplex_t *work, int const *lwork, double* rwork, int* info);
+ void LAPACK_SSYGV(integer_t const* itype, char const* jobz, char const* uplo, integer_t const* n,
+ float* a, integer_t const* lda, float* b, integer_t const* ldb,
+ float* w, float* work, integer_t const* lwork, integer_t* info);
+
+ void LAPACK_DSYGV(integer_t const* itype, char const* jobz, char const* uplo, integer_t const* n,
+ double* a, integer_t const* lda, double* b, integer_t const* ldb,
+ double* w, double* work, integer_t const* lwork, integer_t* info);
+
+ void LAPACK_CHEGV(integer_t const* itype, char const* jobz, char const* uplo, integer_t const* n,
+ fcomplex_t* a, integer_t const* lda, fcomplex_t* b, integer_t const* ldb,
+ float* w, fcomplex_t* work, integer_t const* lwork, float* rwork, integer_t* info);
+
+ void LAPACK_ZHEGV(integer_t const *itype, char const* jobz, char const *uplo, integer_t const * n,
+ dcomplex_t *a, integer_t const *lda, dcomplex_t *b, integer_t const *ldb,
+ double *w, dcomplex_t *work, integer_t const *lwork, double* rwork, integer_t* info);
/*********************************************************************/
@@ -613,160 +613,160 @@
/*********************************************************************/
void LAPACK_SGESVD (char const* jobu, char const* jobvt,
- int const* m, int const* n, float* a, int const* lda,
- float* s, float* u, int const* ldu,
- float* vt, int const* ldvt,
- float* work, int const* lwork, int* info);
+ integer_t const* m, integer_t const* n, float* a, integer_t const* lda,
+ float* s, float* u, integer_t const* ldu,
+ float* vt, integer_t const* ldvt,
+ float* work, integer_t const* lwork, integer_t* info);
void LAPACK_DGESVD (char const* jobu, char const* jobvt,
- int const* m, int const* n, double* a, int const* lda,
- double* s, double* u, int const* ldu,
- double* vt, int const* ldvt,
- double* work, int const* lwork, int* info);
+ integer_t const* m, integer_t const* n, double* a, integer_t const* lda,
+ double* s, double* u, integer_t const* ldu,
+ double* vt, integer_t const* ldvt,
+ double* work, integer_t const* lwork, integer_t* info);
void LAPACK_CGESVD (char const* jobu, char const* jobvt,
- int const* m, int const* n,
- fcomplex_t* a, int const* lda,
- float* s, fcomplex_t* u, int const* ldu,
- fcomplex_t* vt, int const* ldvt,
- fcomplex_t* work, int const* lwork,
- float* rwork, int* info);
+ integer_t const* m, integer_t const* n,
+ fcomplex_t* a, integer_t const* lda,
+ float* s, fcomplex_t* u, integer_t const* ldu,
+ fcomplex_t* vt, integer_t const* ldvt,
+ fcomplex_t* work, integer_t const* lwork,
+ float* rwork, integer_t* info);
void LAPACK_ZGESVD (char const* jobu, char const* jobvt,
- int const* m, int const* n,
- dcomplex_t* a, int const* lda,
- double* s, dcomplex_t* u, int const* ldu,
- dcomplex_t* vt, int const* ldvt,
- dcomplex_t* work, int const* lwork,
- double* rwork, int* info);
-
- void LAPACK_SGESDD (char const* jobz, int const* m, int const* n,
- float* a, int const* lda,
- float* s, float* u, int const* ldu,
- float* vt, int const* ldvt,
- float* work, int const* lwork, int* iwork, int* info);
- void LAPACK_DGESDD (char const* jobz, int const* m, int const* n,
- double* a, int const* lda,
- double* s, double* u, int const* ldu,
- double* vt, int const* ldvt,
- double* work, int const* lwork, int* iwork, int* info);
- void LAPACK_CGESDD (char const* jobz, int const* m, int const* n,
- fcomplex_t* a, int const* lda,
- float* s, fcomplex_t* u, int const* ldu,
- fcomplex_t* vt, int const* ldvt,
- fcomplex_t* work, int const* lwork,
- float* rwork, int* iwork, int* info);
- void LAPACK_ZGESDD (char const* jobz, int const* m, int const* n,
- dcomplex_t* a, int const* lda,
- double* s, dcomplex_t* u, int const* ldu,
- dcomplex_t* vt, int const* ldvt,
- dcomplex_t* work, int const* lwork,
- double* rwork, int* iwork, int* info);
+ integer_t const* m, integer_t const* n,
+ dcomplex_t* a, integer_t const* lda,
+ double* s, dcomplex_t* u, integer_t const* ldu,
+ dcomplex_t* vt, integer_t const* ldvt,
+ dcomplex_t* work, integer_t const* lwork,
+ double* rwork, integer_t* info);
+
+ void LAPACK_SGESDD (char const* jobz, integer_t const* m, integer_t const* n,
+ float* a, integer_t const* lda,
+ float* s, float* u, integer_t const* ldu,
+ float* vt, integer_t const* ldvt,
+ float* work, integer_t const* lwork, integer_t* iwork, integer_t* info);
+ void LAPACK_DGESDD (char const* jobz, integer_t const* m, integer_t const* n,
+ double* a, integer_t const* lda,
+ double* s, double* u, integer_t const* ldu,
+ double* vt, integer_t const* ldvt,
+ double* work, integer_t const* lwork, integer_t* iwork, integer_t* info);
+ void LAPACK_CGESDD (char const* jobz, integer_t const* m, integer_t const* n,
+ fcomplex_t* a, integer_t const* lda,
+ float* s, fcomplex_t* u, integer_t const* ldu,
+ fcomplex_t* vt, integer_t const* ldvt,
+ fcomplex_t* work, integer_t const* lwork,
+ float* rwork, integer_t* iwork, integer_t* info);
+ void LAPACK_ZGESDD (char const* jobz, integer_t const* m, integer_t const* n,
+ dcomplex_t* a, integer_t const* lda,
+ double* s, dcomplex_t* u, integer_t const* ldu,
+ dcomplex_t* vt, integer_t const* ldvt,
+ dcomplex_t* work, integer_t const* lwork,
+ double* rwork, integer_t* iwork, integer_t* info);
/*********************************************************************/
/* QR factorization */
/*********************************************************************/
- void LAPACK_SGEQRF( const int* m, const int* n, float* a, const int* lda,
- float* tau, float* work, const int* lwork, int* info );
- void LAPACK_DGEQRF( const int* m, const int* n, double* a, const int* lda,
- double* tau, double* work, const int* lwork, int* info );
- void LAPACK_CGEQRF( const int* m, const int* n, fcomplex_t* a, const int* lda,
- fcomplex_t* tau, fcomplex_t* work, const int* lwork, int* info );
- void LAPACK_ZGEQRF( const int* m, const int* n, dcomplex_t* a, const int* lda,
- dcomplex_t* tau, dcomplex_t* work, const int* lwork, int* info );
+ void LAPACK_SGEQRF( const integer_t* m, const integer_t* n, float* a, const integer_t* lda,
+ float* tau, float* work, const integer_t* lwork, integer_t* info );
+ void LAPACK_DGEQRF( const integer_t* m, const integer_t* n, double* a, const integer_t* lda,
+ double* tau, double* work, const integer_t* lwork, integer_t* info );
+ void LAPACK_CGEQRF( const integer_t* m, const integer_t* n, fcomplex_t* a, const integer_t* lda,
+ fcomplex_t* tau, fcomplex_t* work, const integer_t* lwork, integer_t* info );
+ void LAPACK_ZGEQRF( const integer_t* m, const integer_t* n, dcomplex_t* a, const integer_t* lda,
+ dcomplex_t* tau, dcomplex_t* work, const integer_t* lwork, integer_t* info );
- void LAPACK_SORMQR( const char* side, const char* trans, const int* m,
- const int* n, const int* k, const float* a,
- const int* lda, const float* tau,
- float* c, const int* ldc, float* work,
- const int* lwork, int* info );
- void LAPACK_DORMQR( const char* side, const char* trans, const int* m,
- const int* n, const int* k, const double* a,
- const int* lda, const double* tau,
- double* c, const int* ldc, double* work,
- const int* lwork, int* info );
- void LAPACK_CUNMQR( const char* side, const char* trans, const int* m,
- const int* n, const int* k, const fcomplex_t* a,
- const int* lda, const fcomplex_t* tau,
- fcomplex_t* c, const int* ldc, fcomplex_t* work,
- const int* lwork, int* info );
- void LAPACK_ZUNMQR( const char* side, const char* trans, const int* m,
- const int* n, const int* k, const dcomplex_t* a,
- const int* lda, const dcomplex_t* tau,
- dcomplex_t* c, const int* ldc, dcomplex_t* work,
- const int* lwork, int* info );
-
- void LAPACK_SORGQR( const int* m, const int* n, const int* k,
- float* a, const int* lda, float* tau,
- float* work, const int* lwork, const int* info);
- void LAPACK_DORGQR( const int* m, const int* n, const int* k,
- double* a, const int* lda, double* tau,
- double* work, const int* lwork, const int* info);
- void LAPACK_CUNGQR( const int* m, const int* n, const int* k,
- fcomplex_t* a, const int* lda, fcomplex_t* tau,
- fcomplex_t* work, const int* lwork, const int* info);
- void LAPACK_ZUNGQR( const int* m, const int* n, const int* k,
- dcomplex_t* a, const int* lda, dcomplex_t* tau,
- dcomplex_t* work, const int* lwork, const int* info);
+ void LAPACK_SORMQR( const char* side, const char* trans, const integer_t* m,
+ const integer_t* n, const integer_t* k, const float* a,
+ const integer_t* lda, const float* tau,
+ float* c, const integer_t* ldc, float* work,
+ const integer_t* lwork, integer_t* info );
+ void LAPACK_DORMQR( const char* side, const char* trans, const integer_t* m,
+ const integer_t* n, const integer_t* k, const double* a,
+ const integer_t* lda, const double* tau,
+ double* c, const integer_t* ldc, double* work,
+ const integer_t* lwork, integer_t* info );
+ void LAPACK_CUNMQR( const char* side, const char* trans, const integer_t* m,
+ const integer_t* n, const integer_t* k, const fcomplex_t* a,
+ const integer_t* lda, const fcomplex_t* tau,
+ fcomplex_t* c, const integer_t* ldc, fcomplex_t* work,
+ const integer_t* lwork, integer_t* info );
+ void LAPACK_ZUNMQR( const char* side, const char* trans, const integer_t* m,
+ const integer_t* n, const integer_t* k, const dcomplex_t* a,
+ const integer_t* lda, const dcomplex_t* tau,
+ dcomplex_t* c, const integer_t* ldc, dcomplex_t* work,
+ const integer_t* lwork, integer_t* info );
+
+ void LAPACK_SORGQR( const integer_t* m, const integer_t* n, const integer_t* k,
+ float* a, const integer_t* lda, float* tau,
+ float* work, const integer_t* lwork, const integer_t* info);
+ void LAPACK_DORGQR( const integer_t* m, const integer_t* n, const integer_t* k,
+ double* a, const integer_t* lda, double* tau,
+ double* work, const integer_t* lwork, const integer_t* info);
+ void LAPACK_CUNGQR( const integer_t* m, const integer_t* n, const integer_t* k,
+ fcomplex_t* a, const integer_t* lda, fcomplex_t* tau,
+ fcomplex_t* work, const integer_t* lwork, const integer_t* info);
+ void LAPACK_ZUNGQR( const integer_t* m, const integer_t* n, const integer_t* k,
+ dcomplex_t* a, const integer_t* lda, dcomplex_t* tau,
+ dcomplex_t* work, const integer_t* lwork, const integer_t* info);
/********************************************************************/
/* Least Squares */
/********************************************************************/
- void LAPACK_SGELS(const char* trans, const int* m, const int* n,
- const int *nrhs, float* a, const int* lda,
- float* b, const int* ldb, float* work,
- const int* lwork, int* info);
- void LAPACK_DGELS(const char* trans, const int* m, const int* n,
- const int *nrhs, double* a, const int* lda,
- double* b, const int* ldb, double* work,
- const int* lwork, int* info);
- void LAPACK_CGELS(const char* trans, const int* m, const int* n,
- const int *nrhs, fcomplex_t* a, const int* lda,
- fcomplex_t* b, const int* ldb, fcomplex_t* work,
- const int* lwork, int* info);
- void LAPACK_ZGELS(const char* trans, const int* m, const int* n,
- const int *nrhs, dcomplex_t* a, const int* lda,
- dcomplex_t* b, const int* ldb, dcomplex_t* work,
- const int* lwork, int* info);
-
-
- void LAPACK_SGELSS(const int *m, const int *n, const int *nrhs,
- float *a, const int *lda, float *b, const int *ldb,
- float *s, const float *rcond, int *rank, float *work,
- const int *lwork, int *info);
- void LAPACK_DGELSS(const int *m, const int *n, const int *nrhs,
- double *a, const int *lda, double *b, const int *ldb,
- double *s, const double *rcond, int *rank, double *work,
- const int *lwork, int *info);
- void LAPACK_CGELSS(const int *m, const int *n, const int *nrhs,
- fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb,
- float *s, const float *rcond, int *rank, fcomplex_t *work,
- const int *lwork, float *rwork, int *info);
- void LAPACK_ZGELSS(const int *m, const int *n, const int *nrhs,
- dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb,
- double *s, const double *rcond, int *rank, dcomplex_t *work,
- const int *lwork, double *rwork, int *info);
-
-
- void LAPACK_SGELSD(const int *m, const int *n, const int *nrhs,
- float *a, const int *lda, float *b, const int *ldb,
- float *s, const float *rcond, int *rank, float *work,
- const int *lwork, int *iwork, int *info);
- void LAPACK_DGELSD(const int *m, const int *n, const int *nrhs,
- double *a, const int *lda, double *b, const int *ldb,
- double *s, const double *rcond, int *rank, double *work,
- const int *lwork, int *iwork, int *info);
- void LAPACK_CGELSD(const int *m, const int *n, const int *nrhs,
- fcomplex_t *a, const int *lda, fcomplex_t *b, const int *ldb,
- float *s, const float *rcond, int *rank, fcomplex_t *work,
- const int *lwork, float *rwork, int *iwork, int *info);
- void LAPACK_ZGELSD(const int *m, const int *n, const int *nrhs,
- dcomplex_t *a, const int *lda, dcomplex_t *b, const int *ldb,
- double *s, const double *rcond, int *rank, dcomplex_t *work,
- const int *lwork, double *rwork, int *iwork, int *info);
+ void LAPACK_SGELS(const char* trans, const integer_t* m, const integer_t* n,
+ const integer_t *nrhs, float* a, const integer_t* lda,
+ float* b, const integer_t* ldb, float* work,
+ const integer_t* lwork, integer_t* info);
+ void LAPACK_DGELS(const char* trans, const integer_t* m, const integer_t* n,
+ const integer_t *nrhs, double* a, const integer_t* lda,
+ double* b, const integer_t* ldb, double* work,
+ const integer_t* lwork, integer_t* info);
+ void LAPACK_CGELS(const char* trans, const integer_t* m, const integer_t* n,
+ const integer_t *nrhs, fcomplex_t* a, const integer_t* lda,
+ fcomplex_t* b, const integer_t* ldb, fcomplex_t* work,
+ const integer_t* lwork, integer_t* info);
+ void LAPACK_ZGELS(const char* trans, const integer_t* m, const integer_t* n,
+ const integer_t *nrhs, dcomplex_t* a, const integer_t* lda,
+ dcomplex_t* b, const integer_t* ldb, dcomplex_t* work,
+ const integer_t* lwork, integer_t* info);
+
+
+ void LAPACK_SGELSS(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ float *a, const integer_t *lda, float *b, const integer_t *ldb,
+ float *s, const float *rcond, integer_t *rank, float *work,
+ const integer_t *lwork, integer_t *info);
+ void LAPACK_DGELSS(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ double *a, const integer_t *lda, double *b, const integer_t *ldb,
+ double *s, const double *rcond, integer_t *rank, double *work,
+ const integer_t *lwork, integer_t *info);
+ void LAPACK_CGELSS(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ fcomplex_t *a, const integer_t *lda, fcomplex_t *b, const integer_t *ldb,
+ float *s, const float *rcond, integer_t *rank, fcomplex_t *work,
+ const integer_t *lwork, float *rwork, integer_t *info);
+ void LAPACK_ZGELSS(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ dcomplex_t *a, const integer_t *lda, dcomplex_t *b, const integer_t *ldb,
+ double *s, const double *rcond, integer_t *rank, dcomplex_t *work,
+ const integer_t *lwork, double *rwork, integer_t *info);
+
+
+ void LAPACK_SGELSD(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ float *a, const integer_t *lda, float *b, const integer_t *ldb,
+ float *s, const float *rcond, integer_t *rank, float *work,
+ const integer_t *lwork, integer_t *iwork, integer_t *info);
+ void LAPACK_DGELSD(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ double *a, const integer_t *lda, double *b, const integer_t *ldb,
+ double *s, const double *rcond, integer_t *rank, double *work,
+ const integer_t *lwork, integer_t *iwork, integer_t *info);
+ void LAPACK_CGELSD(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ fcomplex_t *a, const integer_t *lda, fcomplex_t *b, const integer_t *ldb,
+ float *s, const float *rcond, integer_t *rank, fcomplex_t *work,
+ const integer_t *lwork, float *rwork, integer_t *iwork, integer_t *info);
+ void LAPACK_ZGELSD(const integer_t *m, const integer_t *n, const integer_t *nrhs,
+ dcomplex_t *a, const integer_t *lda, dcomplex_t *b, const integer_t *ldb,
+ double *s, const double *rcond, integer_t *rank, dcomplex_t *work,
+ const integer_t *lwork, double *rwork, integer_t *iwork, integer_t *info);
@@ -774,9 +774,9 @@
/* auxiliary */
/********************************************************************/
- int LAPACK_ILAENV (int const* ispec, const char* name, const char* opt,
- int const* n1, int const* n2, int const* n3,
- int const* n4, int, int);
+ integer_t LAPACK_ILAENV (integer_t const* ispec, const char* name, const char* opt,
+ integer_t const* n1, integer_t const* n2, integer_t const* n3,
+ integer_t const* n4, integer_t, integer_t);
}
Modified: sandbox/boost/numeric/bindings/lapack/orgqr.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/orgqr.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/orgqr.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -56,34 +56,34 @@
inline
- void orgqr(int const m, int const n, int const k,
- float* a, int const lda,
- float* tau, float* work, int const lwork, int& info)
+ void orgqr(integer_t const m, integer_t const n, integer_t const k,
+ float* a, integer_t const lda,
+ float* tau, float* work, integer_t const lwork, integer_t& info)
{
LAPACK_SORGQR (&m, &n, &k, a, &lda, tau, work, &lwork, &info);
}
inline
- void orgqr(int const m, int const n, int const k,
- double* a, int const lda,
- double* tau, double* work, int const lwork, int& info)
+ void orgqr(integer_t const m, integer_t const n, integer_t const k,
+ double* a, integer_t const lda,
+ double* tau, double* work, integer_t const lwork, integer_t& info)
{
LAPACK_DORGQR (&m, &n, &k, a, &lda, tau, work, &lwork, &info);
}
inline
- void orgqr(int const m, int const n, int const k,
- traits::complex_f* a, int const lda,
- traits::complex_f* tau, traits::complex_f* work, int const lwork, int& info)
+ void orgqr(integer_t const m, integer_t const n, integer_t const k,
+ traits::complex_f* a, integer_t const lda,
+ traits::complex_f* tau, traits::complex_f* work, integer_t const lwork, integer_t& info)
{
LAPACK_CUNGQR (&m, &n, &k, traits::complex_ptr(a), &lda, traits::complex_ptr(tau),
traits::complex_ptr(work), &lwork, &info);
}
inline
- void orgqr(int const m, int const n, int const k,
- traits::complex_d* a, int const lda,
- traits::complex_d* tau, traits::complex_d* work, int const lwork, int& info)
+ void orgqr(integer_t const m, integer_t const n, integer_t const k,
+ traits::complex_d* a, integer_t const lda,
+ traits::complex_d* tau, traits::complex_d* work, integer_t const lwork, integer_t& info)
{
LAPACK_ZUNGQR (&m, &n, &k, traits::complex_ptr(a), &lda, traits::complex_ptr(tau),
traits::complex_ptr(work), &lwork, &info);
@@ -104,14 +104,14 @@
>::value));
#endif
- const int m = traits::matrix_size1 (a);
- const int n = traits::matrix_size2 (a);
- const int k = n;
+ const integer_t m = traits::matrix_size1 (a);
+ const integer_t n = traits::matrix_size2 (a);
+ const integer_t k = n;
- assert (std::min<int>(m,n) <= traits::vector_size (tau));
+ assert (std::min<integer_t>(m,n) <= traits::vector_size (tau));
assert (n <= traits::vector_size (work));
- int info;
+ integer_t info;
detail::orgqr (m, n, k,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -128,8 +128,8 @@
template <typename A, typename Tau>
int orgqr (A& a, Tau& tau, optimal_workspace ) {
typedef typename A::value_type value_type ;
- const int n = traits::matrix_size2 (a);
- traits::detail::array<value_type> work(std::max<int>(1, n*32));
+ const std::ptrdiff_t n = traits::matrix_size2 (a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1, n*32));
return orgqr( a, tau, work );
}
@@ -140,8 +140,8 @@
template <typename A, typename Tau>
int orgqr (A& a, Tau& tau, minimal_workspace ) {
typedef typename A::value_type value_type ;
- const int n = traits::matrix_size2 (a);
- traits::detail::array<value_type> work(std::max<int>(1, n));
+ const std::ptrdiff_t n = traits::matrix_size2 (a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1, n));
return orgqr( a, tau, work );
}
@@ -151,8 +151,8 @@
template <typename A, typename Tau, typename Work>
int orgqr (A& a, Tau& tau, detail::workspace1<Work> workspace ) {
typedef typename A::value_type value_type ;
- const int n = traits::matrix_size2 (a);
- traits::detail::array<value_type> work(std::max<int>(1, n));
+ const std::ptrdiff_t n = traits::matrix_size2 (a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1, n));
return orgqr( a, tau, workspace.w_ );
}
Modified: sandbox/boost/numeric/bindings/lapack/ormqr.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/ormqr.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/ormqr.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -65,11 +65,11 @@
namespace detail {
inline
- void ormqr (char const side, char const trans, int const m, int const n,
- int const k, const float* a, int const lda,
+ void ormqr (char const side, char const trans, integer_t const m, integer_t const n,
+ integer_t const k, const float* a, integer_t const lda,
const float* tau, float* c,
- int const ldc, float* work, int const lwork,
- int& info)
+ integer_t const ldc, float* work, integer_t const lwork,
+ integer_t& info)
{
assert ( trans=='N' || trans=='T' );
LAPACK_SORMQR (&side, &trans, &m, &n, &k,
@@ -81,11 +81,11 @@
}
inline
- void ormqr (char const side, char const trans, int const m, int const n,
- int const k, const double* a, int const lda,
+ void ormqr (char const side, char const trans, integer_t const m, integer_t const n,
+ integer_t const k, const double* a, integer_t const lda,
const double* tau, double* c,
- int const ldc, double* work, int const lwork,
- int& info)
+ integer_t const ldc, double* work, integer_t const lwork,
+ integer_t& info)
{
assert ( trans=='N' || trans=='T' );
LAPACK_DORMQR (&side, &trans, &m, &n, &k,
@@ -97,11 +97,11 @@
}
inline
- void ormqr (char const side, char const trans, int const m, int const n,
- int const k, const traits::complex_f* a, int const lda,
+ void ormqr (char const side, char const trans, integer_t const m, integer_t const n,
+ integer_t const k, const traits::complex_f* a, integer_t const lda,
const traits::complex_f* tau, traits::complex_f* c,
- int const ldc, traits::complex_f* work, int const lwork,
- int& info)
+ integer_t const ldc, traits::complex_f* work, integer_t const lwork,
+ integer_t& info)
{
assert ( trans=='N' || trans=='C' );
LAPACK_CUNMQR (&side, &trans, &m, &n, &k,
@@ -113,11 +113,11 @@
}
inline
- void ormqr (char const side, char const trans, int const m, int const n,
- int const k, const traits::complex_d* a, int const lda,
+ void ormqr (char const side, char const trans, integer_t const m, integer_t const n,
+ integer_t const k, const traits::complex_d* a, integer_t const lda,
const traits::complex_d* tau, traits::complex_d* c,
- int const ldc, traits::complex_d* work, int const lwork,
- int& info)
+ integer_t const ldc, traits::complex_d* work, integer_t const lwork,
+ integer_t& info)
{
assert ( trans=='N' || trans=='C' );
LAPACK_ZUNMQR (&side, &trans, &m, &n, &k,
@@ -144,10 +144,10 @@
>::value));
#endif
- int const m = traits::matrix_size1 (c);
- int const n = traits::matrix_size2 (c);
- int const k = traits::vector_size (tau);
- int const lwork = traits::vector_size (work);
+ integer_t const m = traits::matrix_size1 (c);
+ integer_t const n = traits::matrix_size2 (c);
+ integer_t const k = traits::vector_size (tau);
+ integer_t const lwork = traits::vector_size (work);
assert ( side=='L' || side=='R' );
assert ( (side=='L' ? m >= k : n >= k ) );
@@ -160,7 +160,7 @@
assert ( (side=='L' ?
lwork >= n : lwork >= m ) );
- int info;
+ integer_t info;
ormqr (side, trans, m, n, k,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -180,10 +180,10 @@
int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, optimal_workspace ) {
typedef typename A::value_type value_type ;
- int const n_w = (side=='L' ? traits::matrix_size2 (c)
+ std::ptrdiff_t const n_w = (side=='L' ? traits::matrix_size2 (c)
: traits::matrix_size1 (c) );
- traits::detail::array<value_type> work( std::max(1,n_w*32) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,n_w*32) );
return detail::ormqr( side, trans, a, tau, c, work );
}
@@ -194,10 +194,10 @@
int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, minimal_workspace ) {
typedef typename A::value_type value_type ;
- int const n_w = (side=='L' ? traits::matrix_size2 (c)
+ std::ptrdiff_t const n_w = (side=='L' ? traits::matrix_size2 (c)
: traits::matrix_size1 (c) );
- traits::detail::array<value_type> work( std::max(1,n_w) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,n_w) );
return detail::ormqr( side, trans, a, tau, c, work );
}
Modified: sandbox/boost/numeric/bindings/lapack/posv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/posv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/posv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -60,25 +60,25 @@
namespace detail {
inline
- void posv (char const uplo, int const n, int const nrhs,
- float* a, int const lda,
- float* b, int const ldb, int* info)
+ void posv (char const uplo, integer_t const n, integer_t const nrhs,
+ float* a, integer_t const lda,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SPOSV (&uplo, &n, &nrhs, a, &lda, b, &ldb, info);
}
inline
- void posv (char const uplo, int const n, int const nrhs,
- double* a, int const lda,
- double* b, int const ldb, int* info)
+ void posv (char const uplo, integer_t const n, integer_t const nrhs,
+ double* a, integer_t const lda,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DPOSV (&uplo, &n, &nrhs, a, &lda, b, &ldb, info);
}
inline
- void posv (char const uplo, int const n, int const nrhs,
- traits::complex_f* a, int const lda,
- traits::complex_f* b, int const ldb, int* info)
+ void posv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f* a, integer_t const lda,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CPOSV (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda,
@@ -86,9 +86,9 @@
}
inline
- void posv (char const uplo, int const n, int const nrhs,
- traits::complex_d* a, int const lda,
- traits::complex_d* b, int const ldb, int* info)
+ void posv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d* a, integer_t const lda,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZPOSV (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda,
@@ -97,10 +97,10 @@
template <typename SymmMatrA, typename MatrB>
int posv (char const uplo, SymmMatrA& a, MatrB& b) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
- int info;
+ integer_t info;
posv (uplo, n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -163,38 +163,38 @@
namespace detail {
inline
- void potrf (char const uplo, int const n,
- float* a, int const lda, int* info)
+ void potrf (char const uplo, integer_t const n,
+ float* a, integer_t const lda, integer_t* info)
{
LAPACK_SPOTRF (&uplo, &n, a, &lda, info);
}
inline
- void potrf (char const uplo, int const n,
- double* a, int const lda, int* info)
+ void potrf (char const uplo, integer_t const n,
+ double* a, integer_t const lda, integer_t* info)
{
LAPACK_DPOTRF (&uplo, &n, a, &lda, info);
}
inline
- void potrf (char const uplo, int const n,
- traits::complex_f* a, int const lda, int* info)
+ void potrf (char const uplo, integer_t const n,
+ traits::complex_f* a, integer_t const lda, integer_t* info)
{
LAPACK_CPOTRF (&uplo, &n, traits::complex_ptr (a), &lda, info);
}
inline
- void potrf (char const uplo, int const n,
- traits::complex_d* a, int const lda, int* info)
+ void potrf (char const uplo, integer_t const n,
+ traits::complex_d* a, integer_t const lda, integer_t* info)
{
LAPACK_ZPOTRF (&uplo, &n, traits::complex_ptr (a), &lda, info);
}
template <typename SymmMatrA>
int potrf (char const uplo, SymmMatrA& a) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
- int info;
+ integer_t info;
potrf (uplo, n, traits::matrix_storage (a),
traits::leading_dimension (a), &info);
return info;
@@ -245,25 +245,25 @@
namespace detail {
inline
- void potrs (char const uplo, int const n, int const nrhs,
- float const* a, int const lda,
- float* b, int const ldb, int* info)
+ void potrs (char const uplo, integer_t const n, integer_t const nrhs,
+ float const* a, integer_t const lda,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SPOTRS (&uplo, &n, &nrhs, a, &lda, b, &ldb, info);
}
inline
- void potrs (char const uplo, int const n, int const nrhs,
- double const* a, int const lda,
- double* b, int const ldb, int* info)
+ void potrs (char const uplo, integer_t const n, integer_t const nrhs,
+ double const* a, integer_t const lda,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DPOTRS (&uplo, &n, &nrhs, a, &lda, b, &ldb, info);
}
inline
- void potrs (char const uplo, int const n, int const nrhs,
- traits::complex_f const* a, int const lda,
- traits::complex_f* b, int const ldb, int* info)
+ void potrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f const* a, integer_t const lda,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CPOTRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda,
@@ -271,9 +271,9 @@
}
inline
- void potrs (char const uplo, int const n, int const nrhs,
- traits::complex_d const* a, int const lda,
- traits::complex_d* b, int const ldb, int* info)
+ void potrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d const* a, integer_t const lda,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZPOTRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda,
@@ -282,10 +282,10 @@
template <typename SymmMatrA, typename MatrB>
int potrs (char const uplo, SymmMatrA const& a, MatrB& b) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
- int info;
+ integer_t info;
potrs (uplo, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
Modified: sandbox/boost/numeric/bindings/lapack/ppsv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/ppsv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/ppsv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -59,23 +59,23 @@
namespace detail {
inline
- void ppsv (char const uplo, int const n, int const nrhs,
- float* ap, float* b, int const ldb, int* info)
+ void ppsv (char const uplo, integer_t const n, integer_t const nrhs,
+ float* ap, float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SPPSV (&uplo, &n, &nrhs, ap, b, &ldb, info);
}
inline
- void ppsv (char const uplo, int const n, int const nrhs,
- double* ap, double* b, int const ldb, int* info)
+ void ppsv (char const uplo, integer_t const n, integer_t const nrhs,
+ double* ap, double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DPPSV (&uplo, &n, &nrhs, ap, b, &ldb, info);
}
inline
- void ppsv (char const uplo, int const n, int const nrhs,
- traits::complex_f* ap, traits::complex_f* b, int const ldb,
- int* info)
+ void ppsv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f* ap, traits::complex_f* b, integer_t const ldb,
+ integer_t* info)
{
LAPACK_CPPSV (&uplo, &n, &nrhs,
traits::complex_ptr (ap),
@@ -83,9 +83,9 @@
}
inline
- void ppsv (char const uplo, int const n, int const nrhs,
- traits::complex_d* ap, traits::complex_d* b, int const ldb,
- int* info)
+ void ppsv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d* ap, traits::complex_d* b, integer_t const ldb,
+ integer_t* info)
{
LAPACK_ZPPSV (&uplo, &n, &nrhs,
traits::complex_ptr (ap),
@@ -110,12 +110,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::ppsv (uplo, n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::matrix_storage (b),
@@ -137,25 +137,25 @@
namespace detail {
inline
- void pptrf (char const uplo, int const n, float* ap, int* info) {
+ void pptrf (char const uplo, integer_t const n, float* ap, integer_t* info) {
LAPACK_SPPTRF (&uplo, &n, ap, info);
}
inline
- void pptrf (char const uplo, int const n, double* ap, int* info) {
+ void pptrf (char const uplo, integer_t const n, double* ap, integer_t* info) {
LAPACK_DPPTRF (&uplo, &n, ap, info);
}
inline
- void pptrf (char const uplo, int const n,
- traits::complex_f* ap, int* info)
+ void pptrf (char const uplo, integer_t const n,
+ traits::complex_f* ap, integer_t* info)
{
LAPACK_CPPTRF (&uplo, &n, traits::complex_ptr (ap), info);
}
inline
- void pptrf (char const uplo, int const n,
- traits::complex_d* ap, int* info)
+ void pptrf (char const uplo, integer_t const n,
+ traits::complex_d* ap, integer_t* info)
{
LAPACK_ZPPTRF (&uplo, &n, traits::complex_ptr (ap), info);
}
@@ -174,10 +174,10 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::pptrf (uplo, n, traits::matrix_storage (a), &info);
return info;
}
@@ -192,23 +192,23 @@
namespace detail {
inline
- void pptrs (char const uplo, int const n, int const nrhs,
- float const* ap, float* b, int const ldb, int* info)
+ void pptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ float const* ap, float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SPPTRS (&uplo, &n, &nrhs, ap, b, &ldb, info);
}
inline
- void pptrs (char const uplo, int const n, int const nrhs,
- double const* ap, double* b, int const ldb, int* info)
+ void pptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ double const* ap, double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DPPTRS (&uplo, &n, &nrhs, ap, b, &ldb, info);
}
inline
- void pptrs (char const uplo, int const n, int const nrhs,
+ void pptrs (char const uplo, integer_t const n, integer_t const nrhs,
traits::complex_f const* ap,
- traits::complex_f* b, int const ldb, int* info)
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CPPTRS (&uplo, &n, &nrhs,
traits::complex_ptr (ap),
@@ -216,9 +216,9 @@
}
inline
- void pptrs (char const uplo, int const n, int const nrhs,
+ void pptrs (char const uplo, integer_t const n, integer_t const nrhs,
traits::complex_d const* ap,
- traits::complex_d* b, int const ldb, int* info)
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZPPTRS (&uplo, &n, &nrhs,
traits::complex_ptr (ap),
@@ -243,12 +243,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::pptrs (uplo, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
@@ -271,25 +271,25 @@
namespace detail {
inline
- void pptri (char const uplo, int const n, float* ap, int* info) {
+ void pptri (char const uplo, integer_t const n, float* ap, integer_t* info) {
LAPACK_SPPTRI (&uplo, &n, ap, info);
}
inline
- void pptri (char const uplo, int const n, double* ap, int* info) {
+ void pptri (char const uplo, integer_t const n, double* ap, integer_t* info) {
LAPACK_DPPTRI (&uplo, &n, ap, info);
}
inline
- void pptri (char const uplo, int const n,
- traits::complex_f* ap, int* info)
+ void pptri (char const uplo, integer_t const n,
+ traits::complex_f* ap, integer_t* info)
{
LAPACK_CPPTRI (&uplo, &n, traits::complex_ptr (ap), info);
}
inline
- void pptri (char const uplo, int const n,
- traits::complex_d* ap, int* info)
+ void pptri (char const uplo, integer_t const n,
+ traits::complex_d* ap, integer_t* info)
{
LAPACK_ZPPTRI(&uplo, &n, traits::complex_ptr (ap), info);
}
@@ -308,10 +308,10 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::pptri (uplo, n, traits::matrix_storage (a), &info);
return info;
}
Modified: sandbox/boost/numeric/bindings/lapack/ptsv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/ptsv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/ptsv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -44,31 +44,31 @@
namespace detail {
inline
- void ptsv ( int const n, int const nrhs,
- float* d, float* e, float* b, int const ldb, int* info)
+ void ptsv ( integer_t const n, integer_t const nrhs,
+ float* d, float* e, float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SPTSV (&n, &nrhs, d, e, b, &ldb, info);
}
inline
- void ptsv ( int const n, int const nrhs,
- double* d, double* e, double* b, int const ldb, int* info)
+ void ptsv ( integer_t const n, integer_t const nrhs,
+ double* d, double* e, double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DPTSV (&n, &nrhs, d, e, b, &ldb, info);
}
inline
- void ptsv ( int const n, int const nrhs,
- float* d, traits::complex_f* e, traits::complex_f* b, int const ldb,
- int* info)
+ void ptsv ( integer_t const n, integer_t const nrhs,
+ float* d, traits::complex_f* e, traits::complex_f* b, integer_t const ldb,
+ integer_t* info)
{
LAPACK_CPTSV (&n, &nrhs, d, traits::complex_ptr(e), traits::complex_ptr(b), &ldb, info);
}
inline
- void ptsv ( int const n, int const nrhs,
- double* d, traits::complex_d* e, traits::complex_d* b, int const ldb,
- int* info)
+ void ptsv ( integer_t const n, integer_t const nrhs,
+ double* d, traits::complex_d* e, traits::complex_d* b, integer_t const ldb,
+ integer_t* info)
{
LAPACK_ZPTSV (&n, &nrhs, d, traits::complex_ptr(e), traits::complex_ptr(b), &ldb, info);
}
@@ -77,11 +77,11 @@
template <typename D, typename E, typename B>
int ptsv( D& d, E& e, B& b ) {
- int const n = traits::vector_size(d) ;
+ integer_t const n = traits::vector_size(d) ;
assert( n==traits::vector_size(e)+1 ) ;
assert( n==traits::matrix_num_rows(b) ) ;
- int info ;
+ integer_t info ;
detail::ptsv( n, traits::matrix_num_columns (b)
, traits::vector_storage(d)
, traits::vector_storage(e)
@@ -102,23 +102,23 @@
namespace detail {
inline
- void pttrf ( int const n, float* d, float* e, int* info) {
+ void pttrf ( integer_t const n, float* d, float* e, integer_t* info) {
LAPACK_SPTTRF ( &n, d, e, info) ;
}
inline
- void pttrf ( int const n, double* d, double* e, int* info) {
+ void pttrf ( integer_t const n, double* d, double* e, integer_t* info) {
LAPACK_DPTTRF ( &n, d, e, info);
}
inline
- void pttrf ( int const n, float* d, traits::complex_f* e, int* info)
+ void pttrf ( integer_t const n, float* d, traits::complex_f* e, integer_t* info)
{
LAPACK_CPTTRF ( &n, d, traits::complex_ptr(e), info);
}
inline
- void pttrf ( int const n, double* d, traits::complex_d* e, int* info)
+ void pttrf ( integer_t const n, double* d, traits::complex_d* e, integer_t* info)
{
LAPACK_ZPTTRF ( &n, d, traits::complex_ptr(e), info);
}
@@ -127,9 +127,9 @@
template <typename D, typename E>
int pttrf (D& d, E& e) {
- int const n = traits::vector_size (d);
+ integer_t const n = traits::vector_size (d);
assert (n == traits::vector_size (e) + 1);
- int info;
+ integer_t info;
detail::pttrf ( n, traits::vector_storage(d), traits::vector_storage(e), &info);
return info;
}
@@ -147,24 +147,24 @@
namespace detail {
inline
- void pttrs (char const uplo, int const n, int const nrhs,
- float const* d, float const* e, float* b, int const ldb, int* info)
+ void pttrs (char const uplo, integer_t const n, integer_t const nrhs,
+ float const* d, float const* e, float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SPTTRS (&n, &nrhs, d, e, b, &ldb, info);
}
inline
- void pttrs (char const uplo, int const n, int const nrhs,
- double const* d, double const* e, double* b, int const ldb, int* info)
+ void pttrs (char const uplo, integer_t const n, integer_t const nrhs,
+ double const* d, double const* e, double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DPTTRS (&n, &nrhs, d, e, b, &ldb, info);
}
inline
- void pttrs (char const uplo, int const n, int const nrhs,
+ void pttrs (char const uplo, integer_t const n, integer_t const nrhs,
float const* d,
traits::complex_f const* e,
- traits::complex_f* b, int const ldb, int* info)
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CPTTRS (&uplo, &n, &nrhs, d,
traits::complex_ptr (e),
@@ -172,10 +172,10 @@
}
inline
- void pttrs (char const uplo, int const n, int const nrhs,
+ void pttrs (char const uplo, integer_t const n, integer_t const nrhs,
double const* d,
traits::complex_d const* e,
- traits::complex_d* b, int const ldb, int* info)
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZPTTRS (&uplo, &n, &nrhs, d,
traits::complex_ptr (e),
@@ -186,11 +186,11 @@
template <typename D, typename E, typename MatrB>
int pttrs (char uplo, D const& d, E const& e, MatrB& b) {
- int const n = traits::vector_size (d);
+ integer_t const n = traits::vector_size (d);
assert (n == traits::vector_size (e) + 1);
assert (n == traits::matrix_num_rows (b));
- int info;
+ integer_t info;
detail::pttrs (uplo, n, traits::matrix_num_columns (b),
traits::vector_storage (d),
traits::vector_storage (e),
Modified: sandbox/boost/numeric/bindings/lapack/spsv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/spsv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/spsv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -55,25 +55,25 @@
namespace detail {
inline
- void spsv (char const uplo, int const n, int const nrhs,
- float* ap, int* ipiv,
- float* b, int const ldb, int* info)
+ void spsv (char const uplo, integer_t const n, integer_t const nrhs,
+ float* ap, integer_t* ipiv,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SSPSV (&uplo, &n, &nrhs, ap, ipiv, b, &ldb, info);
}
inline
- void spsv (char const uplo, int const n, int const nrhs,
- double* ap, int* ipiv,
- double* b, int const ldb, int* info)
+ void spsv (char const uplo, integer_t const n, integer_t const nrhs,
+ double* ap, integer_t* ipiv,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DSPSV (&uplo, &n, &nrhs, ap, ipiv, b, &ldb, info);
}
inline
- void spsv (char const uplo, int const n, int const nrhs,
- traits::complex_f* ap, int* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void spsv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f* ap, integer_t* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CSPSV (&uplo, &n, &nrhs,
traits::complex_ptr (ap), ipiv,
@@ -81,9 +81,9 @@
}
inline
- void spsv (char const uplo, int const n, int const nrhs,
- traits::complex_d* ap, int* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void spsv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d* ap, integer_t* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZSPSV (&uplo, &n, &nrhs,
traits::complex_ptr (ap), ipiv,
@@ -104,12 +104,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
spsv (uplo, n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::vector_storage (i),
@@ -132,8 +132,8 @@
int spsv (SymmA& a, MatrB& b) {
// with 'internal' pivot vector
- int info = -101;
- traits::detail::array<int> i (traits::matrix_size1 (a));
+ integer_t info = -101;
+ traits::detail::array<integer_t> i (traits::matrix_size1 (a));
if (i.valid())
info = detail::spsv (a, i, b);
@@ -154,29 +154,29 @@
namespace detail {
inline
- void sptrf (char const uplo, int const n,
- float* ap, int* ipiv, int* info)
+ void sptrf (char const uplo, integer_t const n,
+ float* ap, integer_t* ipiv, integer_t* info)
{
LAPACK_SSPTRF (&uplo, &n, ap, ipiv, info);
}
inline
- void sptrf (char const uplo, int const n,
- double* ap, int* ipiv, int* info)
+ void sptrf (char const uplo, integer_t const n,
+ double* ap, integer_t* ipiv, integer_t* info)
{
LAPACK_DSPTRF (&uplo, &n, ap, ipiv, info);
}
inline
- void sptrf (char const uplo, int const n,
- traits::complex_f* ap, int* ipiv, int* info)
+ void sptrf (char const uplo, integer_t const n,
+ traits::complex_f* ap, integer_t* ipiv, integer_t* info)
{
LAPACK_CSPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info);
}
inline
- void sptrf (char const uplo, int const n,
- traits::complex_d* ap, int* ipiv, int* info)
+ void sptrf (char const uplo, integer_t const n,
+ traits::complex_d* ap, integer_t* ipiv, integer_t* info)
{
LAPACK_ZSPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info);
}
@@ -193,12 +193,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (i));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::sptrf (uplo, n, traits::matrix_storage (a),
traits::vector_storage (i), &info);
return info;
@@ -215,25 +215,25 @@
namespace detail {
inline
- void sptrs (char const uplo, int const n, int const nrhs,
- float const* a, int const* ipiv,
- float* b, int const ldb, int* info)
+ void sptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ float const* a, integer_t const* ipiv,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SSPTRS (&uplo, &n, &nrhs, a, ipiv, b, &ldb, info);
}
inline
- void sptrs (char const uplo, int const n, int const nrhs,
- double const* a, int const* ipiv,
- double* b, int const ldb, int* info)
+ void sptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ double const* a, integer_t const* ipiv,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DSPTRS (&uplo, &n, &nrhs, a, ipiv, b, &ldb, info);
}
inline
- void sptrs (char const uplo, int const n, int const nrhs,
- traits::complex_f const* a, int const* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void sptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f const* a, integer_t const* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CSPTRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), ipiv,
@@ -241,9 +241,9 @@
}
inline
- void sptrs (char const uplo, int const n, int const nrhs,
- traits::complex_d const* a, int const* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void sptrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d const* a, integer_t const* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZSPTRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), ipiv,
@@ -266,13 +266,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (i));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
detail::sptrs (uplo, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
@@ -290,30 +290,30 @@
namespace detail {
inline
- void sptri (char const uplo, int const n,
- float* ap, int* ipiv, float* work, int* info)
+ void sptri (char const uplo, integer_t const n,
+ float* ap, integer_t* ipiv, float* work, integer_t* info)
{
LAPACK_SSPTRI (&uplo, &n, ap, ipiv, work, info);
}
inline
- void sptri (char const uplo, int const n,
- double* ap, int* ipiv, double* work, int* info)
+ void sptri (char const uplo, integer_t const n,
+ double* ap, integer_t* ipiv, double* work, integer_t* info)
{
LAPACK_DSPTRI (&uplo, &n, ap, ipiv, work, info);
}
inline
- void sptri (char const uplo, int const n,
- traits::complex_f* ap, int* ipiv, traits::complex_f* work, int* info)
+ void sptri (char const uplo, integer_t const n,
+ traits::complex_f* ap, integer_t* ipiv, traits::complex_f* work, integer_t* info)
{
LAPACK_CSPTRI (&uplo, &n, traits::complex_ptr (ap),
ipiv, traits::complex_ptr (work), info);
}
inline
- void sptri (char const uplo, int const n,
- traits::complex_d* ap, int* ipiv, traits::complex_d* work, int* info)
+ void sptri (char const uplo, integer_t const n,
+ traits::complex_d* ap, integer_t* ipiv, traits::complex_d* work, integer_t* info)
{
LAPACK_ZSPTRI (&uplo, &n, traits::complex_ptr (ap),
ipiv, traits::complex_ptr (work), info);
@@ -330,12 +330,12 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (ipiv));
char uplo = traits::matrix_uplo_tag (a);
- int info;
+ integer_t info;
typedef typename SymmA::value_type value_type;
traits::detail::array<value_type> work(traits::matrix_size1(a));
Modified: sandbox/boost/numeric/bindings/lapack/steqr.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/steqr.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/steqr.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -35,13 +35,13 @@
namespace detail {
inline
- void steqr ( char compz, int n, float* d, float* e, float* z, int ldz, float* work, int& info )
+ void steqr ( char compz, integer_t n, float* d, float* e, float* z, integer_t ldz, float* work, integer_t& info )
{
LAPACK_SSTEQR( &compz, &n, d, e, z, &ldz, work, &info ) ;
}
inline
- void steqr ( char compz, int n, double* d, double* e, double* z, int ldz, double* work, int& info )
+ void steqr ( char compz, integer_t n, double* d, double* e, double* z, integer_t ldz, double* work, integer_t& info )
{
LAPACK_DSTEQR( &compz, &n, d, e, z, &ldz, work, &info ) ;
}
@@ -52,15 +52,15 @@
template <typename D, typename E, typename Z, typename W>
int steqr( char compz, D& d, E& e, Z& z, W& work ) {
- int const n = traits::vector_size (d);
+ integer_t const n = traits::vector_size (d);
assert( traits::vector_size (e) == n-1 );
assert( traits::matrix_size1 (z) == n );
assert( traits::matrix_size2 (z) == n );
assert( compz=='N' || compz=='V' || compz=='I' );
- int lwork = traits::vector_size( work ) ;
+ integer_t lwork = traits::vector_size( work ) ;
- int info;
+ integer_t info;
detail::steqr( compz, n,
traits::vector_storage( d ),
traits::vector_storage( e ),
@@ -74,7 +74,7 @@
template <typename D, typename E, typename Z>
int steqr( char compz, D& d, E& e, Z& z, optimal_workspace ) {
- int lwork = 0 ;
+ integer_t lwork = 0 ;
if (compz != 'N') lwork = 2 * traits::vector_size( d ) - 2 ;
traits::detail::array<typename traits::vector_traits<D>::value_type> work( lwork );
@@ -85,7 +85,7 @@
template <typename D, typename E, typename Z>
int steqr( char compz, D& d, E& e, Z& z, minimal_workspace ) {
- int lwork = 1 ;
+ integer_t lwork = 1 ;
if (compz != 'N') lwork = 2 * traits::vector_size( e ) ;
traits::detail::array<typename traits::vector_traits<D>::value_type> work( lwork );
Modified: sandbox/boost/numeric/bindings/lapack/syev.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/syev.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/syev.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -56,17 +56,17 @@
namespace detail {
inline
- void syev (char const jobz, char const uplo, int const n,
- float* a, int const lda,
- float* w, float* work, int const lwork, int& info)
+ void syev (char const jobz, char const uplo, integer_t const n,
+ float* a, integer_t const lda,
+ float* w, float* work, integer_t const lwork, integer_t& info)
{
LAPACK_SSYEV (&jobz, &uplo, &n, a, &lda, w, work, &lwork, &info);
}
inline
- void syev (char const jobz, char const uplo, int const n,
- double* a, int const lda,
- double* w, double* work, int const lwork, int& info)
+ void syev (char const jobz, char const uplo, integer_t const n,
+ double* a, integer_t const lda,
+ double* w, double* work, integer_t const lwork, integer_t& info)
{
LAPACK_DSYEV (&jobz, &uplo, &n, a, &lda, w, work, &lwork, &info);
}
@@ -82,7 +82,7 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert ( n>0 );
assert (traits::matrix_size2 (a)==n);
assert (traits::leading_dimension (a)>=n);
@@ -91,7 +91,7 @@
assert ( uplo=='U' || uplo=='L' );
assert ( jobz=='N' || jobz=='V' );
- int info;
+ integer_t info;
detail::syev (jobz, uplo, n,
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -109,9 +109,9 @@
int syev (char jobz, char uplo, A& a, W& w, optimal_workspace ) {
typedef typename A::value_type value_type ;
- int const n = traits::matrix_size1 (a);
+ std::ptrdiff_t const n = traits::matrix_size1 (a);
- traits::detail::array<value_type> work( std::max<int>(1,34*n) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,34*n) );
return detail::syev(jobz, uplo, a, w, work);
} // syev()
@@ -121,9 +121,9 @@
int syev (char jobz, char uplo, A& a, W& w, minimal_workspace ) {
typedef typename A::value_type value_type ;
- int const n = traits::matrix_size1 (a);
+ std::ptrdiff_t const n = traits::matrix_size1 (a);
- traits::detail::array<value_type> work( std::max<int>(1,3*n-1) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,3*n-1) );
return detail::syev(jobz, uplo, a, w, work);
} // syev()
@@ -150,7 +150,7 @@
int syev (char jobz, A& a, W& w, optimal_workspace ) {
typedef typename A::value_type value_type ;
- int const n = traits::matrix_size1 (a);
+ std::ptrdiff_t const n = traits::matrix_size1 (a);
char uplo = traits::matrix_uplo_tag( a ) ;
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
typedef typename traits::matrix_traits<A>::matrix_structure matrix_structure ;
@@ -160,7 +160,7 @@
) ;
#endif
- traits::detail::array<value_type> work( std::max<int>(1,34*n) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,34*n) );
return detail::syev(jobz, uplo, a, w, work);
} // syev()
@@ -170,7 +170,7 @@
int syev (char jobz, A& a, W& w, minimal_workspace ) {
typedef typename A::value_type value_type ;
- int const n = traits::matrix_size1 (a);
+ std::ptrdiff_t const n = traits::matrix_size1 (a);
char uplo = traits::matrix_uplo_tag( a ) ;
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
typedef typename traits::matrix_traits<A>::matrix_structure matrix_structure ;
@@ -179,7 +179,7 @@
>::value)
) ;
#endif
- traits::detail::array<value_type> work( std::max<int>(1,3*n-1) );
+ traits::detail::array<value_type> work( std::max<std::ptrdiff_t>(1,3*n-1) );
return detail::syev(jobz, uplo, a, w, work);
} // syev()
Modified: sandbox/boost/numeric/bindings/lapack/syevx.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/syevx.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/syevx.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -17,7 +17,7 @@
template <typename A, typename T, typename W, typename Z, typename IFail, typename Work>
inline
int syevx (
- char jobz, char range, A& a, T vl, T vu, int il, int iu, T abstol, int& m,
+ char jobz, char range, A& a, T vl, T vu, integer_t il, integer_t iu, T abstol, integer_t& m,
W& w, Z& z, IFail& ifail, Work work = optimal_workspace() ) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
Modified: sandbox/boost/numeric/bindings/lapack/sygv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/sygv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/sygv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -16,7 +16,7 @@
template <typename A, typename B, typename W, typename Work>
inline
- int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w, Work work = optimal_workspace()) {
+ int sygv (integer_t itype, char jobz, char uplo, A& a, B& b, W& w, Work work = optimal_workspace()) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
typedef typename A::value_type value_type ;
Modified: sandbox/boost/numeric/bindings/lapack/sysv.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/sysv.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/sysv.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -43,26 +43,26 @@
namespace detail {
inline
- int sytrf_block (float, int const ispec, char const ul, int const n)
+ integer_t sytrf_block (float, integer_t const ispec, char const ul, integer_t const n)
{
char ul2[2] = "x"; ul2[0] = ul;
return ilaenv (ispec, "SSYTRF", ul2, n);
}
inline
- int sytrf_block (double, int const ispec, char const ul, int const n) {
+ integer_t sytrf_block (double, integer_t const ispec, char const ul, integer_t const n) {
char ul2[2] = "x"; ul2[0] = ul;
return ilaenv (ispec, "DSYTRF", ul2, n);
}
inline
- int sytrf_block (traits::complex_f,
- int const ispec, char const ul, int const n)
+ integer_t sytrf_block (traits::complex_f,
+ integer_t const ispec, char const ul, integer_t const n)
{
char ul2[2] = "x"; ul2[0] = ul;
return ilaenv (ispec, "CSYTRF", ul2, n);
}
inline
- int sytrf_block (traits::complex_d,
- int const ispec, char const ul, int const n)
+ integer_t sytrf_block (traits::complex_d,
+ integer_t const ispec, char const ul, integer_t const n)
{
char ul2[2] = "x"; ul2[0] = ul;
return ilaenv (ispec, "ZSYTRF", ul2, n);
@@ -71,7 +71,7 @@
template <typename SymmA>
- int sytrf_block (char const q, char const ul, SymmA const& a)
+ integer_t sytrf_block (char const q, char const ul, SymmA const& a)
{
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -82,7 +82,7 @@
assert (q == 'O' || q == 'M');
assert (ul == 'U' || ul == 'L');
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -90,12 +90,12 @@
#else
typedef typename SymmA::value_type val_t;
#endif
- int ispec = (q == 'O' ? 1 : 2);
+ integer_t ispec = (q == 'O' ? 1 : 2);
return detail::sytrf_block (val_t(), ispec, ul, n);
}
template <typename SymmA>
- int sytrf_block (char const q, SymmA const& a)
+ integer_t sytrf_block (char const q, SymmA const& a)
{
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -106,7 +106,7 @@
assert (q == 'O' || q == 'M');
char ul = traits::matrix_uplo_tag (a);
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -114,12 +114,12 @@
#else
typedef typename SymmA::value_type val_t;
#endif
- int ispec = (q == 'O' ? 1 : 2);
+ integer_t ispec = (q == 'O' ? 1 : 2);
return detail::sytrf_block (val_t(), ispec, ul, n);
}
template <typename SymmA>
- int sytrf_work (char const q, char const ul, SymmA const& a)
+ integer_t sytrf_work (char const q, char const ul, SymmA const& a)
{
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -130,7 +130,7 @@
assert (q == 'O' || q == 'M');
assert (ul == 'U' || ul == 'L');
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -138,7 +138,7 @@
#else
typedef typename SymmA::value_type val_t;
#endif
- int lw = -13;
+ integer_t lw = -13;
if (q == 'M')
lw = 1;
if (q == 'O')
@@ -147,7 +147,7 @@
}
template <typename SymmA>
- int sytrf_work (char const q, SymmA const& a) {
+ integer_t sytrf_work (char const q, SymmA const& a) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -158,7 +158,7 @@
assert (q == 'O' || q == 'M');
char ul = traits::matrix_uplo_tag (a);
- int n = traits::matrix_size1 (a);
+ integer_t n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
@@ -166,7 +166,7 @@
#else
typedef typename SymmA::value_type val_t;
#endif
- int lw = -13;
+ integer_t lw = -13;
if (q == 'M')
lw = 1;
if (q == 'O')
@@ -177,13 +177,13 @@
template <typename SymmA>
inline
- int sysv_work (char const q, char const ul, SymmA const& a) {
+ integer_t sysv_work (char const q, char const ul, SymmA const& a) {
return sytrf_work (q, ul, a);
}
template <typename SymmA>
inline
- int sysv_work (char const q, SymmA const& a) { return sytrf_work (q, a); }
+ integer_t sysv_work (char const q, SymmA const& a) { return sytrf_work (q, a); }
/*
@@ -205,28 +205,28 @@
{
inline
- void sysv (char const uplo, int const n, int const nrhs,
- float* a, int const lda, int* ipiv,
- float* b, int const ldb,
- float* w, int const lw, int* info)
+ void sysv (char const uplo, integer_t const n, integer_t const nrhs,
+ float* a, integer_t const lda, integer_t* ipiv,
+ float* b, integer_t const ldb,
+ float* w, integer_t const lw, integer_t* info)
{
LAPACK_SSYSV (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, w, &lw, info);
}
inline
- void sysv (char const uplo, int const n, int const nrhs,
- double* a, int const lda, int* ipiv,
- double* b, int const ldb,
- double* w, int const lw, int* info)
+ void sysv (char const uplo, integer_t const n, integer_t const nrhs,
+ double* a, integer_t const lda, integer_t* ipiv,
+ double* b, integer_t const ldb,
+ double* w, integer_t const lw, integer_t* info)
{
LAPACK_DSYSV (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, w, &lw, info);
}
inline
- void sysv (char const uplo, int const n, int const nrhs,
- traits::complex_f* a, int const lda, int* ipiv,
- traits::complex_f* b, int const ldb,
- traits::complex_f* w, int const lw, int* info)
+ void sysv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_f* b, integer_t const ldb,
+ traits::complex_f* w, integer_t const lw, integer_t* info)
{
LAPACK_CSYSV (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -235,10 +235,10 @@
}
inline
- void sysv (char const uplo, int const n, int const nrhs,
- traits::complex_d* a, int const lda, int* ipiv,
- traits::complex_d* b, int const ldb,
- traits::complex_d* w, int const lw, int* info)
+ void sysv (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_d* b, integer_t const ldb,
+ traits::complex_d* w, integer_t const lw, integer_t* info)
{
LAPACK_ZSYSV (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -249,12 +249,12 @@
template <typename SymmA, typename MatrB, typename IVec, typename Work>
int sysv (char const ul, SymmA& a, IVec& i, MatrB& b, Work& w)
{
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (i));
- int info;
+ integer_t info;
sysv (ul, n, traits::matrix_size2 (b),
traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -328,13 +328,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
- int info = -101;
- traits::detail::array<int> i (n);
+ integer_t const n = traits::matrix_size1 (a);
+ integer_t info = -101;
+ traits::detail::array<integer_t> i (n);
if (i.valid()) {
info = -102;
- int lw = sytrf_work ('O', ul, a);
+ integer_t lw = sytrf_work ('O', ul, a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<SymmA>::value_type val_t;
@@ -364,14 +364,14 @@
>::value));
#endif
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
char uplo = traits::matrix_uplo_tag (a);
- int info = -101;
- traits::detail::array<int> i (n);
+ integer_t info = -101;
+ traits::detail::array<integer_t> i (n);
if (i.valid()) {
info = -102;
- int lw = sytrf_work ('O', a);
+ integer_t lw = sytrf_work ('O', a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<SymmA>::value_type val_t;
@@ -399,25 +399,25 @@
namespace detail
{
inline
- void sytrf (char const uplo, int const n,
- float* a, int const lda, int* ipiv,
- float* w, int const lw, int* info)
+ void sytrf (char const uplo, integer_t const n,
+ float* a, integer_t const lda, integer_t* ipiv,
+ float* w, integer_t const lw, integer_t* info)
{
LAPACK_SSYTRF (&uplo, &n, a, &lda, ipiv, w, &lw, info);
}
inline
- void sytrf (char const uplo, int const n,
- double* a, int const lda, int* ipiv,
- double* w, int const lw, int* info)
+ void sytrf (char const uplo, integer_t const n,
+ double* a, integer_t const lda, integer_t* ipiv,
+ double* w, integer_t const lw, integer_t* info)
{
LAPACK_DSYTRF (&uplo, &n, a, &lda, ipiv, w, &lw, info);
}
inline
- void sytrf (char const uplo, int const n,
- traits::complex_f* a, int const lda, int* ipiv,
- traits::complex_f* w, int const lw, int* info)
+ void sytrf (char const uplo, integer_t const n,
+ traits::complex_f* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_f* w, integer_t const lw, integer_t* info)
{
LAPACK_CSYTRF (&uplo, &n,
traits::complex_ptr (a), &lda, ipiv,
@@ -425,9 +425,9 @@
}
inline
- void sytrf (char const uplo, int const n,
- traits::complex_d* a, int const lda, int* ipiv,
- traits::complex_d* w, int const lw, int* info)
+ void sytrf (char const uplo, integer_t const n,
+ traits::complex_d* a, integer_t const lda, integer_t* ipiv,
+ traits::complex_d* w, integer_t const lw, integer_t* info)
{
LAPACK_ZSYTRF (&uplo, &n,
traits::complex_ptr (a), &lda, ipiv,
@@ -437,11 +437,11 @@
template <typename SymmA, typename IVec, typename Work>
int sytrf (char const ul, SymmA& a, IVec& i, Work& w) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (i));
- int info;
+ integer_t info;
sytrf (ul, n, traits::matrix_storage (a),
traits::leading_dimension (a),
traits::vector_storage (i),
@@ -500,8 +500,8 @@
>::value));
#endif
- int info = -101;
- int lw = sytrf_work ('O', ul, a);
+ integer_t info = -101;
+ integer_t lw = sytrf_work ('O', ul, a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<SymmA>::value_type val_t;
@@ -527,8 +527,8 @@
#endif
char uplo = traits::matrix_uplo_tag (a);
- int info = -101;
- int lw = sytrf_work ('O', a);
+ integer_t info = -101;
+ integer_t lw = sytrf_work ('O', a);
assert (lw >= 1); // paranoia ?
#ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS
typedef typename traits::matrix_traits<SymmA>::value_type val_t;
@@ -552,26 +552,26 @@
namespace detail {
inline
- void sytrs (char const uplo, int const n, int const nrhs,
- float const* a, int const lda, int const* ipiv,
- float* b, int const ldb, int* info)
+ void sytrs (char const uplo, integer_t const n, integer_t const nrhs,
+ float const* a, integer_t const lda, integer_t const* ipiv,
+ float* b, integer_t const ldb, integer_t* info)
{
LAPACK_SSYTRS (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}
inline
- void sytrs (char const uplo, int const n, int const nrhs,
- double const* a, int const lda, int const* ipiv,
- double* b, int const ldb, int* info)
+ void sytrs (char const uplo, integer_t const n, integer_t const nrhs,
+ double const* a, integer_t const lda, integer_t const* ipiv,
+ double* b, integer_t const ldb, integer_t* info)
{
LAPACK_DSYTRS (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}
inline
- void sytrs (char const uplo, int const n, int const nrhs,
- traits::complex_f const* a, int const lda,
- int const* ipiv,
- traits::complex_f* b, int const ldb, int* info)
+ void sytrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_f const* a, integer_t const lda,
+ integer_t const* ipiv,
+ traits::complex_f* b, integer_t const ldb, integer_t* info)
{
LAPACK_CSYTRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -579,10 +579,10 @@
}
inline
- void sytrs (char const uplo, int const n, int const nrhs,
- traits::complex_d const* a, int const lda,
- int const* ipiv,
- traits::complex_d* b, int const ldb, int* info)
+ void sytrs (char const uplo, integer_t const n, integer_t const nrhs,
+ traits::complex_d const* a, integer_t const lda,
+ integer_t const* ipiv,
+ traits::complex_d* b, integer_t const ldb, integer_t* info)
{
LAPACK_ZSYTRS (&uplo, &n, &nrhs,
traits::complex_ptr (a), &lda, ipiv,
@@ -592,12 +592,12 @@
template <typename SymmA, typename MatrB, typename IVec>
int sytrs (char const ul, SymmA const& a, IVec const& i, MatrB& b) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::matrix_size1 (b));
assert (n == traits::vector_size (i));
- int info;
+ integer_t info;
sytrs (ul, n, traits::matrix_size2 (b),
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
traits::matrix_storage (a),
@@ -661,30 +661,30 @@
namespace detail
{
inline
- void sytri (char const uplo, int const n, float* a, int const lda,
- int const* ipiv, float* work, int* info)
+ void sytri (char const uplo, integer_t const n, float* a, integer_t const lda,
+ integer_t const* ipiv, float* work, integer_t* info)
{
LAPACK_SSYTRI (&uplo, &n, a, &lda, ipiv, work, info);
}
inline
- void sytri (char const uplo, int const n, double* a, int const lda,
- int const* ipiv, double* work, int* info)
+ void sytri (char const uplo, integer_t const n, double* a, integer_t const lda,
+ integer_t const* ipiv, double* work, integer_t* info)
{
LAPACK_DSYTRI (&uplo, &n, a, &lda, ipiv, work, info);
}
inline
- void sytri (char const uplo, int const n, traits::complex_f* a,
- int const lda, int const* ipiv, traits::complex_f* work, int* info)
+ void sytri (char const uplo, integer_t const n, traits::complex_f* a,
+ integer_t const lda, integer_t const* ipiv, traits::complex_f* work, integer_t* info)
{
LAPACK_CSYTRI (&uplo, &n, traits::complex_ptr (a), &lda, ipiv,
traits::complex_ptr (work), info);
}
inline
- void sytri (char const uplo, int const n, traits::complex_d* a,
- int const lda, int const* ipiv, traits::complex_d* work, int* info)
+ void sytri (char const uplo, integer_t const n, traits::complex_d* a,
+ integer_t const lda, integer_t const* ipiv, traits::complex_d* work, integer_t* info)
{
LAPACK_ZSYTRI (&uplo, &n, traits::complex_ptr (a), &lda, ipiv,
traits::complex_ptr (work), info);
@@ -695,12 +695,12 @@
{
assert (ul == 'U' || ul == 'L');
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert (n == traits::matrix_size2 (a));
assert (n == traits::vector_size (ipiv));
assert (n == traits::vector_size (work));
- int info;
+ integer_t info;
//const double* dummy = traits::matrix_storage (a);
detail::sytri (ul, n, traits::matrix_storage (a),
traits::leading_dimension (a),
@@ -731,8 +731,8 @@
#endif
typedef typename SymmA::value_type value_type;
- int n = traits::matrix_size1(a);
- traits::detail::array<value_type> work(std::max<int>(1,n));
+ std::ptrdiff_t n = traits::matrix_size1(a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1,n));
return detail::sytri (ul, a, ipiv, work);
}
@@ -758,8 +758,8 @@
#endif
typedef typename SymmA::value_type value_type;
- int n = traits::matrix_size1(a);
- traits::detail::array<value_type> work(std::max<int>(1,n));
+ std::ptrdiff_t n = traits::matrix_size1(a);
+ traits::detail::array<value_type> work(std::max<std::ptrdiff_t>(1,n));
char uplo = traits::matrix_uplo_tag (a);
return detail::sytri (uplo, a, ipiv, work);
Modified: sandbox/boost/numeric/bindings/lapack/sytrd.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/sytrd.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/sytrd.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -35,13 +35,13 @@
namespace detail {
inline
- void sytrd ( char uplo, int n, float* a, int lda, float* d, float* e, float* tau, float* work, int lwork, int& info )
+ void sytrd ( char uplo, integer_t n, float* a, integer_t lda, float* d, float* e, float* tau, float* work, integer_t lwork, integer_t& info )
{
LAPACK_SSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info ) ;
}
inline
- void sytrd ( char uplo, int n, double* a, int lda, double* d, double* e, double* tau, double* work, int lwork, int& info )
+ void sytrd ( char uplo, integer_t n, double* a, integer_t lda, double* d, double* e, double* tau, double* work, integer_t lwork, integer_t& info )
{
LAPACK_DSYTRD( &uplo, &n, a, &lda, d, e, tau, work, &lwork, &info ) ;
}
@@ -52,17 +52,17 @@
template <typename A, typename D, typename E, typename Tau, typename W>
int sytrd( char uplo, A& a, D& d, E& e, Tau& tau, W& work ) {
- int const n = traits::matrix_size1 (a);
+ integer_t const n = traits::matrix_size1 (a);
assert( traits::matrix_size2 (a) == n );
assert( traits::vector_size (d) == n );
assert( traits::vector_size (e) == n-1 );
assert( traits::vector_size (tau) == n-1 );
assert( uplo=='U' || uplo=='L' );
- int lwork = traits::vector_size( work ) ;
+ integer_t lwork = traits::vector_size( work ) ;
assert( lwork >= 1 );
- int info;
+ integer_t info;
detail::sytrd( uplo, n,
traits::matrix_storage( a ),
traits::leading_dimension( a ),
@@ -77,7 +77,7 @@
template <typename A, typename D, typename E, typename Tau>
int sytrd( char uplo, A& a, D& d, E& e, Tau& tau, optimal_workspace=optimal_workspace() ) {
- int info;
+ integer_t info;
detail::sytrd( uplo, traits::matrix_size1( a ),
traits::matrix_storage( a ),
traits::leading_dimension( a ),
@@ -87,7 +87,7 @@
traits::vector_storage( tau ), -1,
info ) ;
if (info) return info ;
- int lwork = * traits::vector_storage( tau ) ;
+ integer_t lwork = * traits::vector_storage( tau ) ;
traits::detail::array<typename traits::vector_traits<D>::value_type> work( lwork );
@@ -97,7 +97,7 @@
template <typename A, typename D, typename E, typename Tau>
int sytrd( char uplo, A& a, D& d, E& e, Tau& tau, minimal_workspace ) {
- int lwork = 1 ;
+ integer_t lwork = 1 ;
traits::detail::array<typename traits::vector_traits<D>::value_type> work( lwork );
return sytrd( uplo, a, d, e, tau, work ) ;
Modified: sandbox/boost/numeric/bindings/lapack/trevc.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/trevc.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/trevc.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -47,34 +47,34 @@
namespace detail {
inline
- void trevc (char const side, char const howmny, const logical_t* select, int const n,
- float* t, int const ldt, float* vl, int const ldvl, float* vr, int const ldvr,
- int const mm, int& m, float* work, int& info)
+ void trevc (char const side, char const howmny, const logical_t* select, integer_t const n,
+ float* t, integer_t const ldt, float* vl, integer_t const ldvl, float* vr, integer_t const ldvr,
+ integer_t const mm, integer_t& m, float* work, integer_t& info)
{
LAPACK_STREVC (&side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info);
}
inline
- void trevc (char const side, char const howmny, const logical_t* select, int const n,
- double* t, int const ldt, double* vl, int const ldvl, double* vr, int const ldvr,
- int const mm, int& m, double* work, int& info)
+ void trevc (char const side, char const howmny, const logical_t* select, integer_t const n,
+ double* t, integer_t const ldt, double* vl, integer_t const ldvl, double* vr, integer_t const ldvr,
+ integer_t const mm, integer_t& m, double* work, integer_t& info)
{
LAPACK_DTREVC (&side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info);
}
inline
- void trevc (char const side, char const howmny, const logical_t* select, int const n,
- traits::complex_f* t, int const ldt, traits::complex_f* vl, int const ldvl, traits::complex_f* vr, int const ldvr,
- int const mm, int& m, traits::complex_f* work, int& info)
+ void trevc (char const side, char const howmny, const logical_t* select, integer_t const n,
+ traits::complex_f* t, integer_t const ldt, traits::complex_f* vl, integer_t const ldvl, traits::complex_f* vr, integer_t const ldvr,
+ integer_t const mm, integer_t& m, traits::complex_f* work, integer_t& info)
{
LAPACK_CTREVC (&side, &howmny, select, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(vl), &ldvl,
traits::complex_ptr(vr), &ldvr, &mm, &m, traits::complex_ptr(work+n), reinterpret_cast<float*>(work), &info);
}
inline
- void trevc (char const side, char const howmny, const logical_t* select, int const n,
- traits::complex_d* t, int const ldt, traits::complex_d* vl, int const ldvl, traits::complex_d* vr, int const ldvr,
- int const mm, int& m, traits::complex_d* work, int& info)
+ void trevc (char const side, char const howmny, const logical_t* select, integer_t const n,
+ traits::complex_d* t, integer_t const ldt, traits::complex_d* vl, integer_t const ldvl, traits::complex_d* vr, integer_t const ldvr,
+ integer_t const mm, integer_t& m, traits::complex_d* work, integer_t& info)
{
LAPACK_ZTREVC (&side, &howmny, select, &n, traits::complex_ptr(t), &ldt,
traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr,
@@ -102,7 +102,7 @@
>::value));
#endif
- int const n = traits::matrix_size1 (t);
+ integer_t const n = traits::matrix_size1 (t);
assert (n == traits::matrix_size2 (t));
assert (n == traits::matrix_size1 (vl));
assert (n == traits::matrix_size2 (vl));
@@ -112,9 +112,9 @@
logical_t* select=0;
- int mm=n;
- int m;
- int info;
+ integer_t mm=n;
+ integer_t m;
+ integer_t info;
detail::trevc (side, howmny, select, n,
traits::matrix_storage (t),
traits::leading_dimension (t),
Modified: sandbox/boost/numeric/bindings/lapack/trexc.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/lapack/trexc.hpp (original)
+++ sandbox/boost/numeric/bindings/lapack/trexc.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -43,53 +43,53 @@
namespace detail {
inline
- int trexc_work_size( int const n, float ) {return n;}
+ integer_t trexc_work_size( integer_t const n, float ) {return n;}
inline
- int trexc_work_size( int const n, double ) {return n;}
+ integer_t trexc_work_size( integer_t const n, double ) {return n;}
inline
- int trexc_work_size( int const n, traits::complex_f ) {return 0;}
+ integer_t trexc_work_size( integer_t const n, traits::complex_f ) {return 0;}
inline
- int trexc_work_size( int const n, traits::complex_d ) {return 0;}
+ integer_t trexc_work_size( integer_t const n, traits::complex_d ) {return 0;}
}
// Get the minimum size of the work array.
template <typename MatrT>
- int trexc_work_size(const MatrT& t) {
+ integer_t trexc_work_size(const MatrT& t) {
return detail::trexc_work_size( traits::matrix_size1(t), typename MatrT::value_type() );
}
namespace detail {
inline
- void trexc (char const compq, int const n,
- float* t, int const ldt, float* q, int const ldq, int& ifst, int& ilst,
- float* work, int& info)
+ void trexc (char const compq, integer_t const n,
+ float* t, integer_t const ldt, float* q, integer_t const ldq, integer_t& ifst, integer_t& ilst,
+ float* work, integer_t& info)
{
LAPACK_STREXC (&compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info);
}
inline
- void trexc (char const compq, int const n,
- double* t, int const ldt, double* q, int const ldq, int& ifst, int& ilst,
- double* work, int& info)
+ void trexc (char const compq, integer_t const n,
+ double* t, integer_t const ldt, double* q, integer_t const ldq, integer_t& ifst, integer_t& ilst,
+ double* work, integer_t& info)
{
LAPACK_DTREXC (&compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info);
}
inline
- void trexc (char const compq, int const n,
- traits::complex_f* t, int const ldt, traits::complex_f* q, int const ldq, int& ifst, int& ilst,
- float* work, int& info)
+ void trexc (char const compq, integer_t const n,
+ traits::complex_f* t, integer_t const ldt, traits::complex_f* q, integer_t const ldq, integer_t& ifst, integer_t& ilst,
+ float* work, integer_t& info)
{
LAPACK_CTREXC (&compq, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(q), &ldq, &ifst, &ilst, &info);
}
inline
- void trexc (char const compq, int const n,
- traits::complex_d* t, int const ldt, traits::complex_d* q, int const ldq, int& ifst, int& ilst,
- double* work, int& info)
+ void trexc (char const compq, integer_t const n,
+ traits::complex_d* t, integer_t const ldt, traits::complex_d* q, integer_t const ldq, integer_t& ifst, integer_t& ilst,
+ double* work, integer_t& info)
{
LAPACK_ZTREXC (&compq, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(q), &ldq, &ifst, &ilst, &info);
}
@@ -98,7 +98,7 @@
// Reorder Schur factorization with Schur vectors
template <typename MatrT, typename Q, typename Work>
- int trexc (char const compq, MatrT& t, Q& q, int& ifst, int& ilst, Work& work) {
+ int trexc (char const compq, MatrT& t, Q& q, integer_t& ifst, integer_t& ilst, Work& work) {
#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK
BOOST_STATIC_ASSERT((boost::is_same<
@@ -111,13 +111,13 @@
>::value));
#endif
- int const n = traits::matrix_size1 (t);
+ integer_t const n = traits::matrix_size1 (t);
assert (n == traits::matrix_size2 (t));
assert (n == traits::matrix_size1 (q));
assert (n == traits::matrix_size2 (q));
assert (trexc_work_size(t) <= traits::vector_size (work));
- int info;
+ integer_t info;
detail::trexc (compq, n,
traits::matrix_storage (t),
traits::leading_dimension (t),
Modified: sandbox/boost/numeric/bindings/traits/detail/utils.hpp
==============================================================================
--- sandbox/boost/numeric/bindings/traits/detail/utils.hpp (original)
+++ sandbox/boost/numeric/bindings/traits/detail/utils.hpp 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -48,14 +48,14 @@
}
- // converts real/complex to int
- inline int to_int (float f) { return static_cast<int> (f); }
- inline int to_int (double d) { return static_cast<int> (d); }
- inline int to_int (traits::complex_f const& cf) {
- return static_cast<int> (traits::real (cf));
+ // converts real/complex to integer_t
+ inline integer_t to_int (float f) { return static_cast<integer_t> (f); }
+ inline integer_t to_int (double d) { return static_cast<integer_t> (d); }
+ inline integer_t to_int (traits::complex_f const& cf) {
+ return static_cast<integer_t> (traits::real (cf));
}
- inline int to_int (traits::complex_d const& cd) {
- return static_cast<int> (traits::real (cd));
+ inline integer_t to_int (traits::complex_d const& cd) {
+ return static_cast<integer_t> (traits::real (cd));
}
}
Modified: sandbox/boost/numeric/bindings/traits/fortran.h
==============================================================================
--- sandbox/boost/numeric/bindings/traits/fortran.h (original)
+++ sandbox/boost/numeric/bindings/traits/fortran.h 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -36,6 +36,12 @@
#error do not know how to bind to fortran calling convention
#endif
+
+// "g77" or clapack or "gfortran -ff2c"
+//#define BIND_FORTRAN_F2C_RETURN_CONVENTIONS
+// "g77 -fno-f2c" or "gfortran"
+//#define BIND_FORTRAN_NO_F2C_RETURN_CONVENTIONS
+
// As long as f2c return conventions are the common case,
// we turn them on unless requested otherwise
#ifndef BIND_FORTRAN_NO_F2C_RETURN_CONVENTIONS
Modified: sandbox/boost/numeric/bindings/traits/type.h
==============================================================================
--- sandbox/boost/numeric/bindings/traits/type.h (original)
+++ sandbox/boost/numeric/bindings/traits/type.h 2008-12-17 11:23:06 EST (Wed, 17 Dec 2008)
@@ -10,6 +10,18 @@
#ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H
#define BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H
+// "g77" or "gfortran" or mkl_intel_ilp64
+//#undef BIND_FORTRAN_INTEGER_8
+// clapack or "gfortran -fdefault-integer-8" or mkl_intel_lp64
+//#define BIND_FORTRAN_INTEGER_8
+
+#ifndef BIND_FORTRAN_INTEGER_8
+typedef int integer_t ;
+#else
+typedef std::ptrdiff_t integer_t ;
+#endif
+
+
/*
* This header defines the C types that will be mapped to
* COMPLEX and COMPLEX*16 of Fortran
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