|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r58973 - in sandbox/numeric_bindings/boost/numeric/bindings/lapack: . auxiliary computational detail driver
From: rutger_at_[hidden]
Date: 2010-01-13 09:02:23
Author: rutger
Date: 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
New Revision: 58973
URL: http://svn.boost.org/trac/boost/changeset/58973
Log:
Improved handling of traits; introduces a dozen of new routines
Added:
sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantp.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hpcon.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrd.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptri.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppcon.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppequ.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptri.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/spcon.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrd.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptri.hpp (contents, props changed)
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tpcon.hpp (contents, props changed)
Text files modified:
sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp | 3
sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp | 3
sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp | 3
sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp | 3
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp | 13
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp | 4
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp | 3
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp | 206 +++++-----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp | 46 +-
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp | 2
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp | 2
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp | 2
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp | 6
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp | 54 +-
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp | 284 +++++++-------
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp | 31
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp | 4
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp | 3
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp | 267 ++++++-------
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp | 29
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp | 98 ++--
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp | 158 ++++----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp | 77 ++-
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp | 256 ++++++------
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp | 82 ++--
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp | 90 ++--
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp | 208 +++++-----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp | 74 +-
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp | 2
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp | 2
sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h | 138 +++++-
sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h | 74 ++
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp | 1
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp | 132 +++---
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp | 136 +++---
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp | 231 +++++-----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp | 239 ++++++------
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp | 778 +++++++++++++++++++--------------------
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp | 126 +++---
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp | 132 +++---
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp | 225 +++++-----
sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp | 234 +++++------
52 files changed, 2308 insertions(+), 2163 deletions(-)
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -33,6 +33,7 @@
#include <boost/numeric/bindings/lapack/auxiliary/lansp.hpp>
#include <boost/numeric/bindings/lapack/auxiliary/lansy.hpp>
#include <boost/numeric/bindings/lapack/auxiliary/lantb.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lantp.hpp>
#include <boost/numeric/bindings/lapack/auxiliary/lantr.hpp>
#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -97,6 +97,7 @@
template< typename MatrixAB, typename WORK >
static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
$CALL_MIN_SIZE ));
@@ -118,6 +119,7 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( norm, ab, workspace( tmp_work ) );
@@ -133,6 +135,7 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( norm, ab, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -92,6 +92,7 @@
template< typename MatrixAP, typename WORK >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
$CALL_MIN_SIZE ));
BOOST_ASSERT( size_column(ap) >= 0 );
@@ -109,6 +110,7 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( norm, ap, workspace( tmp_work ) );
@@ -124,6 +126,7 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( norm, ap, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansb.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -127,6 +127,7 @@
template< typename MatrixAB, typename WORK >
static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_ASSERT( bandwidth_lower(ab) >= 0 );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
$CALL_MIN_SIZE ));
@@ -148,6 +149,7 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( norm, ab, workspace( tmp_work ) );
@@ -163,6 +165,7 @@
template< typename MatrixAB >
static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab,
optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( norm, ab, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lansp.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -118,6 +118,7 @@
template< typename MatrixAP, typename WORK >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
$CALL_MIN_SIZE ));
BOOST_ASSERT( size_column(ap) >= 0 );
@@ -135,6 +136,7 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
$CALL_MIN_SIZE ) );
return invoke( norm, ap, workspace( tmp_work ) );
@@ -150,6 +152,7 @@
template< typename MatrixAP >
static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
return invoke( norm, ap, minimal_workspace() );
}
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantp.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lantp.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,206 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTP_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTP_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/diag_tag.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for lantp is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantp( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const float* ap, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantp( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const double* ap, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantp( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const std::complex<float>* ap, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_CLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename Diag >
+inline std::ptrdiff_t lantp( const char norm, const char uplo, Diag,
+ const fortran_int_t n, const std::complex<double>* ap, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to lantp.
+//
+template< typename Value >
+struct lantp_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK >
+ static std::ptrdiff_t invoke( const char norm, const char uplo,
+ const MatrixAP& ap, detail::workspace1< WORK > work ) {
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ $CALL_MIN_SIZE ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::lantp( norm, uplo, diag(), size_column(ap),
+ begin_value(ap), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const char uplo,
+ const MatrixAP& ap, minimal_workspace work ) {
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ $CALL_MIN_SIZE ) );
+ return invoke( norm, uplo, ap, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const char uplo,
+ const MatrixAP& ap, optimal_workspace work ) {
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ return invoke( norm, uplo, ap, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( $ARGUMENTS ) {
+ $MIN_SIZE
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the lantp_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for lantp. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename Workspace >
+inline std::ptrdiff_t lantp( const char norm, const char uplo,
+ const MatrixAP& ap, Workspace work ) {
+ return lantp_impl< typename value< MatrixAP >::type >::invoke( norm,
+ uplo, ap, work );
+}
+
+//
+// Overloaded function for lantp. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t lantp( const char norm, const char uplo,
+ const MatrixAP& ap ) {
+ return lantp_impl< typename value< MatrixAP >::type >::invoke( norm,
+ uplo, ap, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -88,8 +88,10 @@
#include <boost/numeric/bindings/lapack/computational/hetrf.hpp>
#include <boost/numeric/bindings/lapack/computational/hetri.hpp>
#include <boost/numeric/bindings/lapack/computational/hetrs.hpp>
+#include <boost/numeric/bindings/lapack/computational/hpcon.hpp>
#include <boost/numeric/bindings/lapack/computational/hprfs.hpp>
#include <boost/numeric/bindings/lapack/computational/hptrf.hpp>
+#include <boost/numeric/bindings/lapack/computational/hptri.hpp>
#include <boost/numeric/bindings/lapack/computational/hptrs.hpp>
#include <boost/numeric/bindings/lapack/computational/lacon.hpp>
#include <boost/numeric/bindings/lapack/computational/latrs.hpp>
@@ -98,8 +100,6 @@
#include <boost/numeric/bindings/lapack/computational/pbrfs.hpp>
#include <boost/numeric/bindings/lapack/computational/pbtrf.hpp>
#include <boost/numeric/bindings/lapack/computational/pbtrs.hpp>
-#include <boost/numeric/bindings/lapack/computational/pftrf.hpp>
-#include <boost/numeric/bindings/lapack/computational/pftri.hpp>
#include <boost/numeric/bindings/lapack/computational/pftrs.hpp>
#include <boost/numeric/bindings/lapack/computational/pocon.hpp>
#include <boost/numeric/bindings/lapack/computational/poequ.hpp>
@@ -107,13 +107,18 @@
#include <boost/numeric/bindings/lapack/computational/potrf.hpp>
#include <boost/numeric/bindings/lapack/computational/potri.hpp>
#include <boost/numeric/bindings/lapack/computational/potrs.hpp>
+#include <boost/numeric/bindings/lapack/computational/ppcon.hpp>
+#include <boost/numeric/bindings/lapack/computational/ppequ.hpp>
#include <boost/numeric/bindings/lapack/computational/pprfs.hpp>
#include <boost/numeric/bindings/lapack/computational/pptrf.hpp>
+#include <boost/numeric/bindings/lapack/computational/pptri.hpp>
#include <boost/numeric/bindings/lapack/computational/pptrs.hpp>
#include <boost/numeric/bindings/lapack/computational/ptrfs.hpp>
#include <boost/numeric/bindings/lapack/computational/pttrs.hpp>
+#include <boost/numeric/bindings/lapack/computational/spcon.hpp>
#include <boost/numeric/bindings/lapack/computational/sprfs.hpp>
#include <boost/numeric/bindings/lapack/computational/sptrf.hpp>
+#include <boost/numeric/bindings/lapack/computational/sptri.hpp>
#include <boost/numeric/bindings/lapack/computational/sptrs.hpp>
#include <boost/numeric/bindings/lapack/computational/sycon.hpp>
#include <boost/numeric/bindings/lapack/computational/syrfs.hpp>
@@ -123,7 +128,7 @@
#include <boost/numeric/bindings/lapack/computational/tbcon.hpp>
#include <boost/numeric/bindings/lapack/computational/tbrfs.hpp>
#include <boost/numeric/bindings/lapack/computational/tbtrs.hpp>
-#include <boost/numeric/bindings/lapack/computational/tftri.hpp>
+#include <boost/numeric/bindings/lapack/computational/tpcon.hpp>
#include <boost/numeric/bindings/lapack/computational/tprfs.hpp>
#include <boost/numeric/bindings/lapack/computational/tptri.hpp>
#include <boost/numeric/bindings/lapack/computational/tptrs.hpp>
@@ -133,6 +138,7 @@
#include <boost/numeric/bindings/lapack/computational/trtrs.hpp>
#include <boost/numeric/bindings/lapack/computational/hbtrd.hpp>
#include <boost/numeric/bindings/lapack/computational/hetrd.hpp>
+#include <boost/numeric/bindings/lapack/computational/hptrd.hpp>
#include <boost/numeric/bindings/lapack/computational/laebz.hpp>
#include <boost/numeric/bindings/lapack/computational/latrd.hpp>
#include <boost/numeric/bindings/lapack/computational/opgtr.hpp>
@@ -141,6 +147,7 @@
#include <boost/numeric/bindings/lapack/computational/ormtr.hpp>
#include <boost/numeric/bindings/lapack/computational/pteqr.hpp>
#include <boost/numeric/bindings/lapack/computational/sbtrd.hpp>
+#include <boost/numeric/bindings/lapack/computational/sptrd.hpp>
#include <boost/numeric/bindings/lapack/computational/stebz.hpp>
#include <boost/numeric/bindings/lapack/computational/stedc.hpp>
#include <boost/numeric/bindings/lapack/computational/stegr.hpp>
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbgst.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -105,6 +105,7 @@
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
const MatrixBB& bb, MatrixX& x, detail::workspace2< WORK,
RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
@@ -116,7 +117,6 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= bandwidth(bb, uplo()) );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
size_column(ab) ));
BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
@@ -146,6 +146,7 @@
template< typename MatrixAB, typename MatrixBB, typename MatrixX >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
const MatrixBB& bb, MatrixX& x, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
@@ -163,6 +164,7 @@
template< typename MatrixAB, typename MatrixBB, typename MatrixX >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
const MatrixBB& bb, MatrixX& x, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( vect, ab, bb, x, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hbtrd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -101,6 +101,7 @@
typename MatrixQ, typename WORK >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorD >::type >::type,
typename remove_const< typename value<
@@ -139,6 +140,7 @@
typename MatrixQ >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
VectorE& e, MatrixQ& q, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column(ab) ) );
return invoke( vect, ab, d, e, q, workspace( tmp_work ) );
@@ -155,6 +157,7 @@
typename MatrixQ >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
VectorE& e, MatrixQ& q, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( vect, ab, d, e, q, minimal_workspace() );
}
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hpcon.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hpcon.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,187 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPCON_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPCON_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for hpcon is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t hpcon( const char uplo, const fortran_int_t n,
+ const std::complex<float>* ap, const fortran_int_t* ipiv,
+ const float anorm, float& rcond, std::complex<float>* work ) {
+ fortran_int_t info(0);
+ LAPACK_CHPCON( &uplo, &n, ap, ipiv, &anorm, &rcond, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t hpcon( const char uplo, const fortran_int_t n,
+ const std::complex<double>* ap, const fortran_int_t* ipiv,
+ const double anorm, double& rcond, std::complex<double>* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZHPCON( &uplo, &n, ap, ipiv, &anorm, &rcond, work, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to hpcon.
+//
+template< typename Value >
+struct hpcon_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorIPIV, typename WORK >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::hpcon( uplo, size_column(ap), begin_value(ap),
+ begin_value(ipiv), anorm, rcond,
+ begin_value(work.select(value_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( uplo, ap, ipiv, anorm, rcond, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ optimal_workspace work ) {
+ return invoke( uplo, ap, ipiv, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the hpcon_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for hpcon. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename VectorIPIV, typename Workspace >
+inline std::ptrdiff_t hpcon( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const typename remove_imaginary<
+ typename value< MatrixAP >::type >::type anorm,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, Workspace work ) {
+ return hpcon_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, anorm, rcond, work );
+}
+
+//
+// Overloaded function for hpcon. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP, typename VectorIPIV >
+inline std::ptrdiff_t hpcon( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const typename remove_imaginary<
+ typename value< MatrixAP >::type >::type anorm,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond ) {
+ return hpcon_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, anorm, rcond, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hprfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -102,10 +102,11 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
typename remove_const< typename value<
@@ -125,21 +126,24 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= n );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::hprfs( uplo(), n, size_column(b), begin_value(ap),
- begin_value(afp), begin_value(ipiv), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::hprfs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(afp), begin_value(ipiv),
+ begin_value(b), stride_major(b), begin_value(x),
+ stride_major(x), begin_value(ferr), begin_value(berr),
begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
}
@@ -154,14 +158,16 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( n, ap, afp, ipiv, b, x, ferr, berr,
- workspace( tmp_work, tmp_rwork ) );
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work,
+ tmp_rwork ) );
}
//
@@ -174,12 +180,11 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
- return invoke( n, ap, afp, ipiv, b, x, ferr, berr,
- minimal_workspace() );
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -219,11 +224,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -237,10 +241,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -254,11 +258,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -272,11 +275,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -290,11 +292,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -308,11 +309,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -326,11 +326,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -344,11 +343,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -362,11 +360,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -380,11 +377,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -398,11 +394,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -416,11 +411,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -434,11 +428,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -452,11 +445,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -470,11 +462,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -488,11 +479,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return hprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t hprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return hprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,373 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRD_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRD_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for hptrd is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t hptrd( UpLo, const fortran_int_t n,
+ std::complex<float>* ap, float* d, float* e,
+ std::complex<float>* tau ) {
+ fortran_int_t info(0);
+ LAPACK_CHPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t hptrd( UpLo, const fortran_int_t n,
+ std::complex<double>* ap, double* d, double* e,
+ std::complex<double>* tau ) {
+ fortran_int_t info(0);
+ LAPACK_ZHPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to hptrd.
+//
+template< typename Value >
+struct hptrd_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+ static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< VectorD >::type >::type,
+ typename remove_const< typename value<
+ VectorE >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixAP >::type >::type,
+ typename remove_const< typename value<
+ VectorTAU >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( size(d) >= size_column(ap) );
+ BOOST_ASSERT( size(tau) >= size_column(ap)-1 );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::hptrd( uplo(), size_column(ap), begin_value(ap),
+ begin_value(d), begin_value(e), begin_value(tau) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the hptrd_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, const VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, const VectorD& d,
+ VectorE& e, VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, VectorD& d, const VectorE& e,
+ VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, VectorD& d,
+ const VectorE& e, VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, const VectorD& d,
+ const VectorE& e, VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, const VectorD& d,
+ const VectorE& e, VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, VectorD& d, VectorE& e,
+ const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, VectorD& d, VectorE& e,
+ const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, const VectorD& d, VectorE& e,
+ const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, const VectorD& d,
+ VectorE& e, const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, VectorD& d, const VectorE& e,
+ const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, VectorD& d,
+ const VectorE& e, const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( MatrixAP& ap, const VectorD& d,
+ const VectorE& e, const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for hptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t hptrd( const MatrixAP& ap, const VectorD& d,
+ const VectorE& e, const VectorTAU& tau ) {
+ return hptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptri.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptri.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,204 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRI_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRI_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for hptri is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t hptri( const char uplo, const fortran_int_t n,
+ std::complex<float>* ap, const fortran_int_t* ipiv,
+ std::complex<float>* work ) {
+ fortran_int_t info(0);
+ LAPACK_CHPTRI( &uplo, &n, ap, ipiv, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t hptri( const char uplo, const fortran_int_t n,
+ std::complex<double>* ap, const fortran_int_t* ipiv,
+ std::complex<double>* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZHPTRI( &uplo, &n, ap, ipiv, work, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to hptri.
+//
+template< typename Value >
+struct hptri_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorIPIV, typename WORK >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, detail::workspace1< WORK > work ) {
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::hptri( uplo, size_column(ap), begin_value(ap),
+ begin_value(ipiv), begin_value(work.select(value_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( uplo, ap, ipiv, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, optimal_workspace work ) {
+ return invoke( uplo, ap, ipiv, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the hptri_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for hptri. Its overload differs for
+// * MatrixAP&
+// * User-defined workspace
+//
+template< typename MatrixAP, typename VectorIPIV, typename Workspace >
+inline std::ptrdiff_t hptri( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, Workspace work ) {
+ return hptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, work );
+}
+
+//
+// Overloaded function for hptri. Its overload differs for
+// * MatrixAP&
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP, typename VectorIPIV >
+inline std::ptrdiff_t hptri( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv ) {
+ return hptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, optimal_workspace() );
+}
+
+//
+// Overloaded function for hptri. Its overload differs for
+// * const MatrixAP&
+// * User-defined workspace
+//
+template< typename MatrixAP, typename VectorIPIV, typename Workspace >
+inline std::ptrdiff_t hptri( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, Workspace work ) {
+ return hptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, work );
+}
+
+//
+// Overloaded function for hptri. Its overload differs for
+// * const MatrixAP&
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP, typename VectorIPIV >
+inline std::ptrdiff_t hptri( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv ) {
+ return hptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/hptrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -48,12 +48,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-inline std::ptrdiff_t hptrs( const char uplo, const fortran_int_t n,
+template< typename UpLo >
+inline std::ptrdiff_t hptrs( UpLo, const fortran_int_t n,
const fortran_int_t nrhs, const std::complex<float>* ap,
const fortran_int_t* ipiv, std::complex<float>* b,
const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_CHPTRS( &uplo, &n, &nrhs, ap, ipiv, b, &ldb, &info );
+ LAPACK_CHPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b,
+ &ldb, &info );
return info;
}
@@ -62,12 +64,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-inline std::ptrdiff_t hptrs( const char uplo, const fortran_int_t n,
+template< typename UpLo >
+inline std::ptrdiff_t hptrs( UpLo, const fortran_int_t n,
const fortran_int_t nrhs, const std::complex<double>* ap,
const fortran_int_t* ipiv, std::complex<double>* b,
const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_ZHPTRS( &uplo, &n, &nrhs, ap, ipiv, b, &ldb, &info );
+ LAPACK_ZHPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b,
+ &ldb, &info );
return info;
}
@@ -90,21 +94,23 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
+ MatrixB& b ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(ap) >= n*(n+1)/2 );
- BOOST_ASSERT( size(ipiv) >= n );
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::hptrs( uplo, n, size_column(b), begin_value(ap),
- begin_value(ipiv), begin_value(b), stride_major(b) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::hptrs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(ipiv), begin_value(b),
+ stride_major(b) );
}
};
@@ -124,10 +130,10 @@
// * MatrixB&
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
-inline std::ptrdiff_t hptrs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv, MatrixB& b ) {
- return hptrs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, ipiv, b );
+inline std::ptrdiff_t hptrs( const MatrixAP& ap, const VectorIPIV& ipiv,
+ MatrixB& b ) {
+ return hptrs_impl< typename value< MatrixAP >::type >::invoke( ap,
+ ipiv, b );
}
//
@@ -135,10 +141,10 @@
// * const MatrixB&
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
-inline std::ptrdiff_t hptrs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv, const MatrixB& b ) {
- return hptrs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, ipiv, b );
+inline std::ptrdiff_t hptrs( const MatrixAP& ap, const VectorIPIV& ipiv,
+ const MatrixB& b ) {
+ return hptrs_impl< typename value< MatrixAP >::type >::invoke( ap,
+ ipiv, b );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -184,6 +184,7 @@
typename MatrixW >
static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a,
VectorE& e, VectorTAU& tau, MatrixW& w ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixA >::type >::type,
typename remove_const< typename value<
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orglq.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -98,7 +98,6 @@
typename remove_const< typename value<
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( k >= k );
BOOST_ASSERT( m >= 0 );
BOOST_ASSERT( n >= m );
BOOST_ASSERT( size(tau) >= k );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgql.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -98,9 +98,7 @@
typename remove_const< typename value<
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( k >= k );
BOOST_ASSERT( m >= 0 );
- BOOST_ASSERT( n >= n );
BOOST_ASSERT( size(tau) >= k );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgqr.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -98,10 +98,8 @@
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
BOOST_ASSERT( size(tau) >= size(tau) );
- BOOST_ASSERT( size(tau) >= size(tau) );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
size_column(a) ));
- BOOST_ASSERT( size_column(a) >= size_column(a) );
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
BOOST_ASSERT( size_row(a) >= 0 );
BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/orgrq.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -98,7 +98,6 @@
typename remove_const< typename value<
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( k >= k );
BOOST_ASSERT( m >= 0 );
BOOST_ASSERT( n >= m );
BOOST_ASSERT( size(tau) >= k );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbequ.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -134,6 +134,7 @@
template< typename MatrixAB, typename VectorS >
static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s,
real_type& scond, real_type& amax ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
@@ -168,6 +169,7 @@
template< typename MatrixAB, typename VectorS >
static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s,
real_type& scond, real_type& amax ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
BOOST_ASSERT( size_column(ab) >= 0 );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbrfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -153,6 +153,7 @@
static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
@@ -215,6 +216,7 @@
static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
@@ -235,6 +237,7 @@
static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() );
}
@@ -276,6 +279,7 @@
static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
typename remove_const< typename value<
@@ -334,6 +338,7 @@
static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
@@ -354,6 +359,7 @@
static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb,
const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbstf.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -118,6 +118,7 @@
//
template< typename MatrixAB >
static std::ptrdiff_t invoke( MatrixAB& ab ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
BOOST_ASSERT( size_column(ab) >= 0 );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pbtrf.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -118,6 +118,7 @@
//
template< typename MatrixAB >
static std::ptrdiff_t invoke( MatrixAB& ab ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
BOOST_ASSERT( size_column(ab) >= 0 );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pftrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -48,13 +48,13 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename TransR, typename UpLo >
-inline std::ptrdiff_t pftrs( TransR, UpLo, const fortran_int_t n,
+template< typename TransR >
+inline std::ptrdiff_t pftrs( TransR, const char uplo, const fortran_int_t n,
const fortran_int_t nrhs, const float* a, float* b,
const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_SPFTRS( &lapack_option< TransR >::value, &lapack_option<
- UpLo >::value, &n, &nrhs, a, b, &ldb, &info );
+ LAPACK_SPFTRS( &lapack_option< TransR >::value, &uplo, &n, &nrhs, a, b,
+ &ldb, &info );
return info;
}
@@ -63,13 +63,13 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename TransR, typename UpLo >
-inline std::ptrdiff_t pftrs( TransR, UpLo, const fortran_int_t n,
+template< typename TransR >
+inline std::ptrdiff_t pftrs( TransR, const char uplo, const fortran_int_t n,
const fortran_int_t nrhs, const double* a, double* b,
const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_DPFTRS( &lapack_option< TransR >::value, &lapack_option<
- UpLo >::value, &n, &nrhs, a, b, &ldb, &info );
+ LAPACK_DPFTRS( &lapack_option< TransR >::value, &uplo, &n, &nrhs, a, b,
+ &ldb, &info );
return info;
}
@@ -78,13 +78,13 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename TransR, typename UpLo >
-inline std::ptrdiff_t pftrs( TransR, UpLo, const fortran_int_t n,
+template< typename TransR >
+inline std::ptrdiff_t pftrs( TransR, const char uplo, const fortran_int_t n,
const fortran_int_t nrhs, const std::complex<float>* a,
std::complex<float>* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_CPFTRS( &lapack_option< TransR >::value, &lapack_option<
- UpLo >::value, &n, &nrhs, a, b, &ldb, &info );
+ LAPACK_CPFTRS( &lapack_option< TransR >::value, &uplo, &n, &nrhs, a, b,
+ &ldb, &info );
return info;
}
@@ -93,13 +93,13 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename TransR, typename UpLo >
-inline std::ptrdiff_t pftrs( TransR, UpLo, const fortran_int_t n,
+template< typename TransR >
+inline std::ptrdiff_t pftrs( TransR, const char uplo, const fortran_int_t n,
const fortran_int_t nrhs, const std::complex<double>* a,
std::complex<double>* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_ZPFTRS( &lapack_option< TransR >::value, &lapack_option<
- UpLo >::value, &n, &nrhs, a, b, &ldb, &info );
+ LAPACK_ZPFTRS( &lapack_option< TransR >::value, &uplo, &n, &nrhs, a, b,
+ &ldb, &info );
return info;
}
@@ -122,8 +122,8 @@
// * Asserts that most arguments make sense.
//
template< typename VectorA, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t n, const VectorA& a,
- MatrixB& b ) {
+ static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
+ const VectorA& a, MatrixB& b ) {
typedef typename result_of::trans_tag< VectorA, order >::type transr;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorA >::type >::type,
@@ -135,7 +135,7 @@
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pftrs( transr(), uplo(), n, size_column(b),
+ return detail::pftrs( transr(), uplo, n, size_column(b),
begin_value(a), begin_value(b), stride_major(b) );
}
@@ -156,10 +156,10 @@
// * MatrixB&
//
template< typename VectorA, typename MatrixB >
-inline std::ptrdiff_t pftrs( const fortran_int_t n, const VectorA& a,
- MatrixB& b ) {
- return pftrs_impl< typename value< VectorA >::type >::invoke( n, a,
- b );
+inline std::ptrdiff_t pftrs( const char uplo, const fortran_int_t n,
+ const VectorA& a, MatrixB& b ) {
+ return pftrs_impl< typename value< VectorA >::type >::invoke( uplo,
+ n, a, b );
}
//
@@ -167,10 +167,10 @@
// * const MatrixB&
//
template< typename VectorA, typename MatrixB >
-inline std::ptrdiff_t pftrs( const fortran_int_t n, const VectorA& a,
- const MatrixB& b ) {
- return pftrs_impl< typename value< VectorA >::type >::invoke( n, a,
- b );
+inline std::ptrdiff_t pftrs( const char uplo, const fortran_int_t n,
+ const VectorA& a, const MatrixB& b ) {
+ return pftrs_impl< typename value< VectorA >::type >::invoke( uplo,
+ n, a, b );
}
} // namespace lapack
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppcon.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppcon.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,316 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPCON_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPCON_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for ppcon is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppcon( UpLo, const fortran_int_t n, const float* ap,
+ const float anorm, float& rcond, float* work, fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_SPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond,
+ work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppcon( UpLo, const fortran_int_t n, const double* ap,
+ const double anorm, double& rcond, double* work,
+ fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_DPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond,
+ work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppcon( UpLo, const fortran_int_t n,
+ const std::complex<float>* ap, const float anorm, float& rcond,
+ std::complex<float>* work, float* rwork ) {
+ fortran_int_t info(0);
+ LAPACK_CPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond,
+ work, rwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppcon( UpLo, const fortran_int_t n,
+ const std::complex<double>* ap, const double anorm, double& rcond,
+ std::complex<double>* work, double* rwork ) {
+ fortran_int_t info(0);
+ LAPACK_ZPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond,
+ work, rwork, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to ppcon.
+//
+template< typename Value, typename Enable = void >
+struct ppcon_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct ppcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK, typename IWORK >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
+ real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ min_size_iwork( size_column(ap) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::ppcon( uplo(), size_column(ap), begin_value(ap), anorm,
+ rcond, begin_value(work.select(real_type())),
+ begin_value(work.select(fortran_int_t())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
+ real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< fortran_int_t > tmp_iwork(
+ min_size_iwork( size_column(ap) ) );
+ return invoke( ap, anorm, rcond, workspace( tmp_work, tmp_iwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
+ real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 3*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array iwork.
+ //
+ static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct ppcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK, typename RWORK >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
+ real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::ppcon( uplo(), size_column(ap), begin_value(ap), anorm,
+ rcond, begin_value(work.select(value_type())),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
+ real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( ap, anorm, rcond, workspace( tmp_work, tmp_rwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm,
+ real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array rwork.
+ //
+ static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the ppcon_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for ppcon. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename Workspace >
+inline std::ptrdiff_t ppcon( const MatrixAP& ap,
+ const typename remove_imaginary< typename value<
+ MatrixAP >::type >::type anorm, typename remove_imaginary<
+ typename value< MatrixAP >::type >::type& rcond, Workspace work ) {
+ return ppcon_impl< typename value< MatrixAP >::type >::invoke( ap,
+ anorm, rcond, work );
+}
+
+//
+// Overloaded function for ppcon. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t ppcon( const MatrixAP& ap,
+ const typename remove_imaginary< typename value<
+ MatrixAP >::type >::type anorm, typename remove_imaginary<
+ typename value< MatrixAP >::type >::type& rcond ) {
+ return ppcon_impl< typename value< MatrixAP >::type >::invoke( ap,
+ anorm, rcond, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppequ.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ppequ.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,214 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPEQU_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPEQU_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for ppequ is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppequ( UpLo, const fortran_int_t n, const float* ap,
+ float* s, float& scond, float& amax ) {
+ fortran_int_t info(0);
+ LAPACK_SPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax,
+ &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppequ( UpLo, const fortran_int_t n, const double* ap,
+ double* s, double& scond, double& amax ) {
+ fortran_int_t info(0);
+ LAPACK_DPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax,
+ &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppequ( UpLo, const fortran_int_t n,
+ const std::complex<float>* ap, float* s, float& scond, float& amax ) {
+ fortran_int_t info(0);
+ LAPACK_CPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax,
+ &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t ppequ( UpLo, const fortran_int_t n,
+ const std::complex<double>* ap, double* s, double& scond,
+ double& amax ) {
+ fortran_int_t info(0);
+ LAPACK_ZPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax,
+ &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to ppequ.
+//
+template< typename Value, typename Enable = void >
+struct ppequ_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct ppequ_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorS >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, VectorS& s,
+ real_type& scond, real_type& amax ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixAP >::type >::type,
+ typename remove_const< typename value<
+ VectorS >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::ppequ( uplo(), size_column(ap), begin_value(ap),
+ begin_value(s), scond, amax );
+ }
+
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct ppequ_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorS >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, VectorS& s,
+ real_type& scond, real_type& amax ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ BOOST_STATIC_ASSERT( (is_mutable< VectorS >::value) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::ppequ( uplo(), size_column(ap), begin_value(ap),
+ begin_value(s), scond, amax );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the ppequ_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for ppequ. Its overload differs for
+// * VectorS&
+//
+template< typename MatrixAP, typename VectorS >
+inline std::ptrdiff_t ppequ( const MatrixAP& ap, VectorS& s,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& scond, typename remove_imaginary<
+ typename value< MatrixAP >::type >::type& amax ) {
+ return ppequ_impl< typename value< MatrixAP >::type >::invoke( ap, s,
+ scond, amax );
+}
+
+//
+// Overloaded function for ppequ. Its overload differs for
+// * const VectorS&
+//
+template< typename MatrixAP, typename VectorS >
+inline std::ptrdiff_t ppequ( const MatrixAP& ap, const VectorS& s,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& scond, typename remove_imaginary<
+ typename value< MatrixAP >::type >::type& amax ) {
+ return ppequ_impl< typename value< MatrixAP >::type >::invoke( ap, s,
+ scond, amax );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pprfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -142,17 +142,17 @@
// * Deduces the required arguments for dispatching to LAPACK, and
// * Asserts that most arguments make sense.
//
- template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
- VectorAFP >::type >::type >::value) );
+ MatrixAFP >::type >::type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
@@ -172,21 +172,24 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
BOOST_ASSERT( size(berr) >= size_column(b) );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ min_size_iwork( size_column(ap) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pprfs( uplo(), n, size_column(b), begin_value(ap),
- begin_value(afp), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(real_type())),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::pprfs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(afp), begin_value(b),
+ stride_major(b), begin_value(x), stride_major(x),
+ begin_value(ferr), begin_value(berr),
+ begin_value(work.select(real_type())),
begin_value(work.select(fortran_int_t())) );
}
@@ -197,16 +200,17 @@
// invoke static member function
// * Enables the unblocked algorithm (BLAS level 2)
//
- template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( n, ap, afp, b, x, ferr, berr, workspace( tmp_work,
+ min_size_iwork( size_column(ap) ) );
+ return invoke( ap, afp, b, x, ferr, berr, workspace( tmp_work,
tmp_iwork ) );
}
@@ -217,13 +221,13 @@
// invoke static member
// * Enables the blocked algorithm (BLAS level 3)
//
- template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
- return invoke( n, ap, afp, b, x, ferr, berr, minimal_workspace() );
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, afp, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -258,13 +262,13 @@
// * Deduces the required arguments for dispatching to LAPACK, and
// * Asserts that most arguments make sense.
//
- template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
typename remove_const< typename value<
@@ -272,7 +276,7 @@
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
- VectorAFP >::type >::type >::value) );
+ MatrixAFP >::type >::type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
@@ -284,20 +288,24 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pprfs( uplo(), n, size_column(b), begin_value(ap),
- begin_value(afp), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(value_type())),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::pprfs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(afp), begin_value(b),
+ stride_major(b), begin_value(x), stride_major(x),
+ begin_value(ferr), begin_value(berr),
+ begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
}
@@ -308,15 +316,17 @@
// invoke static member function
// * Enables the unblocked algorithm (BLAS level 2)
//
- template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( n, ap, afp, b, x, ferr, berr, workspace( tmp_work,
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( ap, afp, b, x, ferr, berr, workspace( tmp_work,
tmp_rwork ) );
}
@@ -327,13 +337,13 @@
// invoke static member
// * Enables the blocked algorithm (BLAS level 3)
//
- template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+ template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
optimal_workspace work ) {
- return invoke( n, ap, afp, b, x, ferr, berr, minimal_workspace() );
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, afp, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -370,13 +380,13 @@
// * VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -387,12 +397,11 @@
// * VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -403,14 +412,13 @@
// * VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -421,12 +429,12 @@
// * VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -437,14 +445,13 @@
// * VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -455,12 +462,12 @@
// * VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -471,14 +478,13 @@
// * VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -489,12 +495,12 @@
// * VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -505,14 +511,13 @@
// * const VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -523,12 +528,12 @@
// * const VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -539,14 +544,13 @@
// * const VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -557,12 +561,12 @@
// * const VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -573,14 +577,13 @@
// * const VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -591,12 +594,12 @@
// * const VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
@@ -607,14 +610,13 @@
// * const VectorBERR&
// * User-defined workspace
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR,
typename Workspace >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
- Workspace work ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, work );
}
@@ -625,12 +627,12 @@
// * const VectorBERR&
// * Default workspace-type (optimal)
//
-template< typename MatrixAP, typename VectorAFP, typename MatrixB,
+template< typename MatrixAP, typename MatrixAFP, typename MatrixB,
typename MatrixX, typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t pprfs( const fortran_int_t n,
- const MatrixAP& ap, const VectorAFP& afp, const MatrixB& b,
- const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
- return pprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t pprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
+ return pprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, b, x, ferr, berr, optimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrf.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -113,6 +113,7 @@
//
template< typename MatrixAP >
static std::ptrdiff_t invoke( MatrixAP& ap ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
BOOST_ASSERT( size_column(ap) >= 0 );
return detail::pptrf( uplo(), size_column(ap), begin_value(ap) );
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptri.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptri.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,156 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRI_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRI_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for pptri is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t pptri( const char uplo, const fortran_int_t n,
+ float* ap ) {
+ fortran_int_t info(0);
+ LAPACK_SPPTRI( &uplo, &n, ap, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t pptri( const char uplo, const fortran_int_t n,
+ double* ap ) {
+ fortran_int_t info(0);
+ LAPACK_DPPTRI( &uplo, &n, ap, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t pptri( const char uplo, const fortran_int_t n,
+ std::complex<float>* ap ) {
+ fortran_int_t info(0);
+ LAPACK_CPPTRI( &uplo, &n, ap, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t pptri( const char uplo, const fortran_int_t n,
+ std::complex<double>* ap ) {
+ fortran_int_t info(0);
+ LAPACK_ZPPTRI( &uplo, &n, ap, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to pptri.
+//
+template< typename Value >
+struct pptri_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap ) {
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::pptri( uplo, size_column(ap), begin_value(ap) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the pptri_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for pptri. Its overload differs for
+// * MatrixAP&
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t pptri( const char uplo, MatrixAP& ap ) {
+ return pptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap );
+}
+
+//
+// Overloaded function for pptri. Its overload differs for
+// * const MatrixAP&
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t pptri( const char uplo, const MatrixAP& ap ) {
+ return pptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/pptrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -121,20 +121,21 @@
// * Deduces the required arguments for dispatching to LAPACK, and
// * Asserts that most arguments make sense.
//
- template< typename VectorAP, typename MatrixB >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const VectorAP& ap, MatrixB& b ) {
+ template< typename MatrixAP, typename MatrixB >
+ static std::ptrdiff_t invoke( const MatrixAP& ap, MatrixB& b ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename value< VectorAP >::type >::type,
+ typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::pptrs( uplo(), n, size_column(b), begin_value(ap),
- begin_value(b), stride_major(b) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::pptrs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(b), stride_major(b) );
}
};
@@ -153,10 +154,9 @@
// Overloaded function for pptrs. Its overload differs for
// * MatrixB&
//
-template< typename VectorAP, typename MatrixB >
-inline std::ptrdiff_t pptrs( const fortran_int_t n,
- const VectorAP& ap, MatrixB& b ) {
- return pptrs_impl< typename value< VectorAP >::type >::invoke( n, ap,
+template< typename MatrixAP, typename MatrixB >
+inline std::ptrdiff_t pptrs( const MatrixAP& ap, MatrixB& b ) {
+ return pptrs_impl< typename value< MatrixAP >::type >::invoke( ap,
b );
}
@@ -164,10 +164,9 @@
// Overloaded function for pptrs. Its overload differs for
// * const MatrixB&
//
-template< typename VectorAP, typename MatrixB >
-inline std::ptrdiff_t pptrs( const fortran_int_t n,
- const VectorAP& ap, const MatrixB& b ) {
- return pptrs_impl< typename value< VectorAP >::type >::invoke( n, ap,
+template< typename MatrixAP, typename MatrixB >
+inline std::ptrdiff_t pptrs( const MatrixAP& ap, const MatrixB& b ) {
+ return pptrs_impl< typename value< MatrixAP >::type >::invoke( ap,
b );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbgst.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -100,6 +100,7 @@
typename WORK >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
const MatrixBB& bb, MatrixX& x, detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
@@ -111,7 +112,6 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixAB >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_ASSERT( bandwidth(ab, uplo()) >= 0 );
- BOOST_ASSERT( bandwidth(bb, uplo()) >= bandwidth(bb, uplo()) );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
size_column(ab) ));
BOOST_ASSERT( size_column(ab) >= 0 );
@@ -138,6 +138,7 @@
template< typename MatrixAB, typename MatrixBB, typename MatrixX >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
const MatrixBB& bb, MatrixX& x, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column(ab) ) );
return invoke( vect, ab, bb, x, workspace( tmp_work ) );
@@ -153,6 +154,7 @@
template< typename MatrixAB, typename MatrixBB, typename MatrixX >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab,
const MatrixBB& bb, MatrixX& x, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( vect, ab, bb, x, minimal_workspace() );
}
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sbtrd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -99,6 +99,7 @@
typename MatrixQ, typename WORK >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAB >::type >::type,
typename remove_const< typename value<
@@ -141,6 +142,7 @@
typename MatrixQ >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
VectorE& e, MatrixQ& q, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column(ab) ) );
return invoke( vect, ab, d, e, q, workspace( tmp_work ) );
@@ -157,6 +159,7 @@
typename MatrixQ >
static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d,
VectorE& e, MatrixQ& q, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
return invoke( vect, ab, d, e, q, minimal_workspace() );
}
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/spcon.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/spcon.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,304 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPCON_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPCON_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for spcon is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t spcon( const char uplo, const fortran_int_t n,
+ const float* ap, const fortran_int_t* ipiv, const float anorm,
+ float& rcond, float* work, fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_SSPCON( &uplo, &n, ap, ipiv, &anorm, &rcond, work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t spcon( const char uplo, const fortran_int_t n,
+ const double* ap, const fortran_int_t* ipiv, const double anorm,
+ double& rcond, double* work, fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_DSPCON( &uplo, &n, ap, ipiv, &anorm, &rcond, work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t spcon( const char uplo, const fortran_int_t n,
+ const std::complex<float>* ap, const fortran_int_t* ipiv,
+ const float anorm, float& rcond, std::complex<float>* work ) {
+ fortran_int_t info(0);
+ LAPACK_CSPCON( &uplo, &n, ap, ipiv, &anorm, &rcond, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t spcon( const char uplo, const fortran_int_t n,
+ const std::complex<double>* ap, const fortran_int_t* ipiv,
+ const double anorm, double& rcond, std::complex<double>* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZSPCON( &uplo, &n, ap, ipiv, &anorm, &rcond, work, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to spcon.
+//
+template< typename Value, typename Enable = void >
+struct spcon_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct spcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorIPIV, typename WORK,
+ typename IWORK >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ detail::workspace2< WORK, IWORK > work ) {
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ min_size_iwork( size_column(ap) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::spcon( uplo, size_column(ap), begin_value(ap),
+ begin_value(ipiv), anorm, rcond,
+ begin_value(work.select(real_type())),
+ begin_value(work.select(fortran_int_t())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< fortran_int_t > tmp_iwork(
+ min_size_iwork( size_column(ap) ) );
+ return invoke( uplo, ap, ipiv, anorm, rcond, workspace( tmp_work,
+ tmp_iwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ optimal_workspace work ) {
+ return invoke( uplo, ap, ipiv, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array iwork.
+ //
+ static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct spcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorIPIV, typename WORK >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ detail::workspace1< WORK > work ) {
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::spcon( uplo, size_column(ap), begin_value(ap),
+ begin_value(ipiv), anorm, rcond,
+ begin_value(work.select(value_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( uplo, ap, ipiv, anorm, rcond, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const real_type anorm, real_type& rcond,
+ optimal_workspace work ) {
+ return invoke( uplo, ap, ipiv, anorm, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the spcon_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for spcon. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename VectorIPIV, typename Workspace >
+inline std::ptrdiff_t spcon( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const typename remove_imaginary<
+ typename value< MatrixAP >::type >::type anorm,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, Workspace work ) {
+ return spcon_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, anorm, rcond, work );
+}
+
+//
+// Overloaded function for spcon. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP, typename VectorIPIV >
+inline std::ptrdiff_t spcon( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const typename remove_imaginary<
+ typename value< MatrixAP >::type >::type anorm,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond ) {
+ return spcon_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, anorm, rcond, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sprfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -145,10 +145,11 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
@@ -172,22 +173,24 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= n );
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ min_size_iwork( size_column(ap) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sprfs( uplo(), n, size_column(b), begin_value(ap),
- begin_value(afp), begin_value(ipiv), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::sprfs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(afp), begin_value(ipiv),
+ begin_value(b), stride_major(b), begin_value(x),
+ stride_major(x), begin_value(ferr), begin_value(berr),
begin_value(work.select(real_type())),
begin_value(work.select(fortran_int_t())) );
}
@@ -202,15 +205,16 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( n, ap, afp, ipiv, b, x, ferr, berr,
- workspace( tmp_work, tmp_iwork ) );
+ min_size_iwork( size_column(ap) ) );
+ return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work,
+ tmp_iwork ) );
}
//
@@ -223,12 +227,11 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
- return invoke( n, ap, afp, ipiv, b, x, ferr, berr,
- minimal_workspace() );
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -266,10 +269,11 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
+ RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
typename remove_const< typename value<
@@ -289,21 +293,24 @@
BOOST_STATIC_ASSERT( (is_mutable< MatrixX >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(afp) >= n*(n+1)/2 );
BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(ipiv) >= n );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sprfs( uplo(), n, size_column(b), begin_value(ap),
- begin_value(afp), begin_value(ipiv), begin_value(b),
- stride_major(b), begin_value(x), stride_major(x),
- begin_value(ferr), begin_value(berr),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::sprfs( uplo(), size_column(ap), size_column(b),
+ begin_value(ap), begin_value(afp), begin_value(ipiv),
+ begin_value(b), stride_major(b), begin_value(x),
+ stride_major(x), begin_value(ferr), begin_value(berr),
begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
}
@@ -318,14 +325,16 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- minimal_workspace work ) {
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( n, ap, afp, ipiv, b, x, ferr, berr,
- workspace( tmp_work, tmp_rwork ) );
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work,
+ tmp_rwork ) );
}
//
@@ -338,12 +347,11 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- optimal_workspace work ) {
- return invoke( n, ap, afp, ipiv, b, x, ferr, berr,
- minimal_workspace() );
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -383,11 +391,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
- Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -401,10 +408,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -418,11 +425,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -436,11 +442,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -454,11 +459,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -472,11 +476,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -490,11 +493,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -508,11 +510,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -526,11 +527,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -544,11 +544,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -562,11 +561,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -580,11 +578,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ VectorFERR& ferr, const VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -598,11 +595,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -616,11 +612,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
@@ -634,11 +629,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, work );
}
@@ -652,11 +646,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t sprfs( const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return sprfs_impl< typename value< MatrixAP >::type >::invoke( n, ap,
+inline std::ptrdiff_t sprfs( const MatrixAP& ap, const MatrixAFP& afp,
+ const VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ const VectorFERR& ferr, const VectorBERR& berr ) {
+ return sprfs_impl< typename value< MatrixAP >::type >::invoke( ap,
afp, ipiv, b, x, ferr, berr, optimal_workspace() );
}
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,375 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRD_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRD_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+//
+// The LAPACK-backend for sptrd is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t sptrd( UpLo, const fortran_int_t n, float* ap, float* d,
+ float* e, float* tau ) {
+ fortran_int_t info(0);
+ LAPACK_SSPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo >
+inline std::ptrdiff_t sptrd( UpLo, const fortran_int_t n, double* ap,
+ double* d, double* e, double* tau ) {
+ fortran_int_t info(0);
+ LAPACK_DSPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to sptrd.
+//
+template< typename Value >
+struct sptrd_impl {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+ static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixAP >::type >::type,
+ typename remove_const< typename value<
+ VectorD >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixAP >::type >::type,
+ typename remove_const< typename value<
+ VectorE >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
+ typename value< MatrixAP >::type >::type,
+ typename remove_const< typename value<
+ VectorTAU >::type >::type >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorD >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorE >::value) );
+ BOOST_STATIC_ASSERT( (is_mutable< VectorTAU >::value) );
+ BOOST_ASSERT( size(d) >= size_column(ap) );
+ BOOST_ASSERT( size(tau) >= size_column(ap)-1 );
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::sptrd( uplo(), size_column(ap), begin_value(ap),
+ begin_value(d), begin_value(e), begin_value(tau) );
+ }
+
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the sptrd_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, const VectorD& d, VectorE& e,
+ VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, const VectorD& d,
+ VectorE& e, VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, VectorD& d, const VectorE& e,
+ VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, VectorD& d,
+ const VectorE& e, VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, const VectorD& d,
+ const VectorE& e, VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, const VectorD& d,
+ const VectorE& e, VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, VectorD& d, VectorE& e,
+ const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, VectorD& d, VectorE& e,
+ const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, const VectorD& d, VectorE& e,
+ const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, const VectorD& d,
+ VectorE& e, const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, VectorD& d, const VectorE& e,
+ const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, VectorD& d,
+ const VectorE& e, const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( MatrixAP& ap, const VectorD& d,
+ const VectorE& e, const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+//
+// Overloaded function for sptrd. Its overload differs for
+// * const MatrixAP&
+// * const VectorD&
+// * const VectorE&
+// * const VectorTAU&
+//
+template< typename MatrixAP, typename VectorD, typename VectorE,
+ typename VectorTAU >
+inline std::ptrdiff_t sptrd( const MatrixAP& ap, const VectorD& d,
+ const VectorE& e, const VectorTAU& tau ) {
+ return sptrd_impl< typename value< MatrixAP >::type >::invoke( ap, d,
+ e, tau );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrf.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -115,6 +115,7 @@
//
template< typename MatrixAP, typename VectorIPIV >
static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorIPIV >::value) );
BOOST_ASSERT( size_column(ap) >= 0 );
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptri.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptri.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,301 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRI_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRI_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for sptri is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+inline std::ptrdiff_t sptri( const char uplo, const fortran_int_t n, float* ap,
+ const fortran_int_t* ipiv, float* work ) {
+ fortran_int_t info(0);
+ LAPACK_SSPTRI( &uplo, &n, ap, ipiv, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+inline std::ptrdiff_t sptri( const char uplo, const fortran_int_t n,
+ double* ap, const fortran_int_t* ipiv, double* work ) {
+ fortran_int_t info(0);
+ LAPACK_DSPTRI( &uplo, &n, ap, ipiv, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+inline std::ptrdiff_t sptri( const char uplo, const fortran_int_t n,
+ std::complex<float>* ap, const fortran_int_t* ipiv,
+ std::complex<float>* work ) {
+ fortran_int_t info(0);
+ LAPACK_CSPTRI( &uplo, &n, ap, ipiv, work, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+inline std::ptrdiff_t sptri( const char uplo, const fortran_int_t n,
+ std::complex<double>* ap, const fortran_int_t* ipiv,
+ std::complex<double>* work ) {
+ fortran_int_t info(0);
+ LAPACK_ZSPTRI( &uplo, &n, ap, ipiv, work, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to sptri.
+//
+template< typename Value, typename Enable = void >
+struct sptri_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct sptri_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorIPIV, typename WORK >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, detail::workspace1< WORK > work ) {
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::sptri( uplo, size_column(ap), begin_value(ap),
+ begin_value(ipiv), begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, minimal_workspace work ) {
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( uplo, ap, ipiv, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, optimal_workspace work ) {
+ return invoke( uplo, ap, ipiv, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct sptri_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename VectorIPIV, typename WORK >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, detail::workspace1< WORK > work ) {
+ BOOST_STATIC_ASSERT( (is_mutable< MatrixAP >::value) );
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::sptri( uplo, size_column(ap), begin_value(ap),
+ begin_value(ipiv), begin_value(work.select(value_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, minimal_workspace work ) {
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( uplo, ap, ipiv, workspace( tmp_work ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP, typename VectorIPIV >
+ static std::ptrdiff_t invoke( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, optimal_workspace work ) {
+ return invoke( uplo, ap, ipiv, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the sptri_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for sptri. Its overload differs for
+// * MatrixAP&
+// * User-defined workspace
+//
+template< typename MatrixAP, typename VectorIPIV, typename Workspace >
+inline std::ptrdiff_t sptri( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv, Workspace work ) {
+ return sptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, work );
+}
+
+//
+// Overloaded function for sptri. Its overload differs for
+// * MatrixAP&
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP, typename VectorIPIV >
+inline std::ptrdiff_t sptri( const char uplo, MatrixAP& ap,
+ const VectorIPIV& ipiv ) {
+ return sptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, optimal_workspace() );
+}
+
+//
+// Overloaded function for sptri. Its overload differs for
+// * const MatrixAP&
+// * User-defined workspace
+//
+template< typename MatrixAP, typename VectorIPIV, typename Workspace >
+inline std::ptrdiff_t sptri( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, Workspace work ) {
+ return sptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, work );
+}
+
+//
+// Overloaded function for sptri. Its overload differs for
+// * const MatrixAP&
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP, typename VectorIPIV >
+inline std::ptrdiff_t sptri( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv ) {
+ return sptri_impl< typename value< MatrixAP >::type >::invoke( uplo,
+ ap, ipiv, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/sptrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -116,21 +116,22 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, MatrixB& b ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(ap) >= n*(n+1)/2 );
- BOOST_ASSERT( size(ipiv) >= n );
+ BOOST_ASSERT( size(ipiv) >= size_column(ap) );
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::sptrs( uplo, n, size_column(b), begin_value(ap),
- begin_value(ipiv), begin_value(b), stride_major(b) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::sptrs( uplo, size_column(ap), size_column(b),
+ begin_value(ap), begin_value(ipiv), begin_value(b),
+ stride_major(b) );
}
};
@@ -150,10 +151,10 @@
// * MatrixB&
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
-inline std::ptrdiff_t sptrs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv, MatrixB& b ) {
+inline std::ptrdiff_t sptrs( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, MatrixB& b ) {
return sptrs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, ipiv, b );
+ ap, ipiv, b );
}
//
@@ -161,10 +162,10 @@
// * const MatrixB&
//
template< typename MatrixAP, typename VectorIPIV, typename MatrixB >
-inline std::ptrdiff_t sptrs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const VectorIPIV& ipiv, const MatrixB& b ) {
+inline std::ptrdiff_t sptrs( const char uplo, const MatrixAP& ap,
+ const VectorIPIV& ipiv, const MatrixB& b ) {
return sptrs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, ipiv, b );
+ ap, ipiv, b );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbcon.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -55,14 +55,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t tbcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tbcon( const char norm, UpLo, Diag,
const fortran_int_t n, const fortran_int_t kd, const float* ab,
const fortran_int_t ldab, float& rcond, float* work,
fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_STBCON( &norm, &uplo, &lapack_option< Diag >::value, &n, &kd, ab,
- &ldab, &rcond, work, iwork, &info );
+ LAPACK_STBCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, &kd, ab, &ldab, &rcond, work, iwork, &info );
return info;
}
@@ -71,14 +71,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t tbcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tbcon( const char norm, UpLo, Diag,
const fortran_int_t n, const fortran_int_t kd, const double* ab,
const fortran_int_t ldab, double& rcond, double* work,
fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_DTBCON( &norm, &uplo, &lapack_option< Diag >::value, &n, &kd, ab,
- &ldab, &rcond, work, iwork, &info );
+ LAPACK_DTBCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, &kd, ab, &ldab, &rcond, work, iwork, &info );
return info;
}
@@ -87,14 +87,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t tbcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tbcon( const char norm, UpLo, Diag,
const fortran_int_t n, const fortran_int_t kd,
const std::complex<float>* ab, const fortran_int_t ldab, float& rcond,
std::complex<float>* work, float* rwork ) {
fortran_int_t info(0);
- LAPACK_CTBCON( &norm, &uplo, &lapack_option< Diag >::value, &n, &kd, ab,
- &ldab, &rcond, work, rwork, &info );
+ LAPACK_CTBCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, &kd, ab, &ldab, &rcond, work, rwork, &info );
return info;
}
@@ -103,14 +103,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t tbcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tbcon( const char norm, UpLo, Diag,
const fortran_int_t n, const fortran_int_t kd,
const std::complex<double>* ab, const fortran_int_t ldab,
double& rcond, std::complex<double>* work, double* rwork ) {
fortran_int_t info(0);
- LAPACK_ZTBCON( &norm, &uplo, &lapack_option< Diag >::value, &n, &kd, ab,
- &ldab, &rcond, work, rwork, &info );
+ LAPACK_ZTBCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, &kd, ab, &ldab, &rcond, work, rwork, &info );
return info;
}
@@ -139,9 +139,10 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixAB, typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
- detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK,
+ IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_ASSERT( kd >= 0 );
BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
@@ -152,7 +153,7 @@
BOOST_ASSERT( size_column(ab) >= 0 );
BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
BOOST_ASSERT( stride_major(ab) >= kd+1 );
- return detail::tbcon( norm, uplo, diag(), size_column(ab), kd,
+ return detail::tbcon( norm, uplo(), diag(), size_column(ab), kd,
begin_value(ab), stride_major(ab), rcond,
begin_value(work.select(real_type())),
begin_value(work.select(fortran_int_t())) );
@@ -166,16 +167,15 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
- minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( size_column(ab) ) );
- return invoke( norm, uplo, kd, ab, rcond, workspace( tmp_work,
- tmp_iwork ) );
+ return invoke( norm, kd, ab, rcond, workspace( tmp_work, tmp_iwork ) );
}
//
@@ -186,11 +186,11 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
- optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( norm, uplo, kd, ab, rcond, minimal_workspace() );
+ return invoke( norm, kd, ab, rcond, minimal_workspace() );
}
//
@@ -226,9 +226,10 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixAB, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
- detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK,
+ RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_ASSERT( kd >= 0 );
BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
@@ -239,7 +240,7 @@
BOOST_ASSERT( size_column(ab) >= 0 );
BOOST_ASSERT( size_minor(ab) == 1 || stride_minor(ab) == 1 );
BOOST_ASSERT( stride_major(ab) >= kd+1 );
- return detail::tbcon( norm, uplo, diag(), size_column(ab), kd,
+ return detail::tbcon( norm, uplo(), diag(), size_column(ab), kd,
begin_value(ab), stride_major(ab), rcond,
begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
@@ -253,16 +254,15 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
- minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
size_column(ab) ) );
- return invoke( norm, uplo, kd, ab, rcond, workspace( tmp_work,
- tmp_rwork ) );
+ return invoke( norm, kd, ab, rcond, workspace( tmp_work, tmp_rwork ) );
}
//
@@ -273,11 +273,11 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixAB >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab, real_type& rcond,
- optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( norm, uplo, kd, ab, rcond, minimal_workspace() );
+ return invoke( norm, kd, ab, rcond, minimal_workspace() );
}
//
@@ -312,12 +312,11 @@
// * User-defined workspace
//
template< typename MatrixAB, typename Workspace >
-inline std::ptrdiff_t tbcon( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab,
- typename remove_imaginary< typename value<
+inline std::ptrdiff_t tbcon( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, typename remove_imaginary< typename value<
MatrixAB >::type >::type& rcond, Workspace work ) {
return tbcon_impl< typename value< MatrixAB >::type >::invoke( norm,
- uplo, kd, ab, rcond, work );
+ kd, ab, rcond, work );
}
//
@@ -325,12 +324,11 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAB >
-inline std::ptrdiff_t tbcon( const char norm, const char uplo,
- const fortran_int_t kd, const MatrixAB& ab,
- typename remove_imaginary< typename value<
+inline std::ptrdiff_t tbcon( const char norm, const fortran_int_t kd,
+ const MatrixAB& ab, typename remove_imaginary< typename value<
MatrixAB >::type >::type& rcond ) {
return tbcon_impl< typename value< MatrixAB >::type >::invoke( norm,
- uplo, kd, ab, rcond, optimal_workspace() );
+ kd, ab, rcond, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbrfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -56,17 +56,16 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const float* ab, const fortran_int_t ldab,
- const float* b, const fortran_int_t ldb, const float* x,
- const fortran_int_t ldx, float* ferr, float* berr, float* work,
- fortran_int_t* iwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs, const float* ab,
+ const fortran_int_t ldab, const float* b, const fortran_int_t ldb,
+ const float* x, const fortran_int_t ldx, float* ferr, float* berr,
+ float* work, fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_STBRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, x, &ldx, ferr,
- berr, work, iwork, &info );
+ LAPACK_STBRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
return info;
}
@@ -75,17 +74,16 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const double* ab, const fortran_int_t ldab,
- const double* b, const fortran_int_t ldb, const double* x,
- const fortran_int_t ldx, double* ferr, double* berr, double* work,
- fortran_int_t* iwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs, const double* ab,
+ const fortran_int_t ldab, const double* b, const fortran_int_t ldb,
+ const double* x, const fortran_int_t ldx, double* ferr, double* berr,
+ double* work, fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_DTBRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, x, &ldx, ferr,
- berr, work, iwork, &info );
+ LAPACK_DTBRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
return info;
}
@@ -94,18 +92,17 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const std::complex<float>* ab,
- const fortran_int_t ldab, const std::complex<float>* b,
- const fortran_int_t ldb, const std::complex<float>* x,
- const fortran_int_t ldx, float* ferr, float* berr,
- std::complex<float>* work, float* rwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs,
+ const std::complex<float>* ab, const fortran_int_t ldab,
+ const std::complex<float>* b, const fortran_int_t ldb,
+ const std::complex<float>* x, const fortran_int_t ldx, float* ferr,
+ float* berr, std::complex<float>* work, float* rwork ) {
fortran_int_t info(0);
- LAPACK_CTBRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, x, &ldx, ferr,
- berr, work, rwork, &info );
+ LAPACK_CTBRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info );
return info;
}
@@ -114,18 +111,17 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const std::complex<double>* ab,
- const fortran_int_t ldab, const std::complex<double>* b,
- const fortran_int_t ldb, const std::complex<double>* x,
- const fortran_int_t ldx, double* ferr, double* berr,
- std::complex<double>* work, double* rwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs,
+ const std::complex<double>* ab, const fortran_int_t ldab,
+ const std::complex<double>* b, const fortran_int_t ldb,
+ const std::complex<double>* x, const fortran_int_t ldx, double* ferr,
+ double* berr, std::complex<double>* work, double* rwork ) {
fortran_int_t info(0);
- LAPACK_ZTBRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, x, &ldx, ferr,
- berr, work, rwork, &info );
+ LAPACK_ZTBRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info );
return info;
}
@@ -156,10 +152,11 @@
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename IWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAB >::type >::type,
@@ -195,7 +192,7 @@
size_column(ab)) );
BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
size_column(ab)) );
- return detail::tbrfs( uplo, trans(), diag(), size_column(ab), kd,
+ return detail::tbrfs( uplo(), trans(), diag(), size_column(ab), kd,
size_column(b), begin_value(ab), stride_major(ab),
begin_value(b), stride_major(b), begin_value(x),
stride_major(x), begin_value(ferr), begin_value(berr),
@@ -212,15 +209,16 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( size_column(ab) ) );
- return invoke( uplo, kd, ab, b, x, ferr, berr, workspace( tmp_work,
+ return invoke( kd, ab, b, x, ferr, berr, workspace( tmp_work,
tmp_iwork ) );
}
@@ -233,11 +231,12 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( uplo, kd, ab, b, x, ferr, berr, minimal_workspace() );
+ return invoke( kd, ab, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -275,10 +274,11 @@
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename RWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
@@ -310,7 +310,7 @@
size_column(ab)) );
BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
size_column(ab)) );
- return detail::tbrfs( uplo, trans(), diag(), size_column(ab), kd,
+ return detail::tbrfs( uplo(), trans(), diag(), size_column(ab), kd,
size_column(b), begin_value(ab), stride_major(ab),
begin_value(b), stride_major(b), begin_value(x),
stride_major(x), begin_value(ferr), begin_value(berr),
@@ -327,15 +327,16 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
size_column(ab) ) );
- return invoke( uplo, kd, ab, b, x, ferr, berr, workspace( tmp_work,
+ return invoke( kd, ab, b, x, ferr, berr, workspace( tmp_work,
tmp_rwork ) );
}
@@ -348,11 +349,12 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
- return invoke( uplo, kd, ab, b, x, ferr, berr, minimal_workspace() );
+ return invoke( kd, ab, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -390,11 +392,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, work );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, work );
}
//
@@ -405,11 +407,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, VectorBERR& berr ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, optimal_workspace() );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -420,11 +422,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, work );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, work );
}
//
@@ -435,11 +437,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
const VectorFERR& ferr, VectorBERR& berr ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, optimal_workspace() );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -450,11 +452,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, work );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, work );
}
//
@@ -465,11 +467,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
VectorFERR& ferr, const VectorBERR& berr ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, optimal_workspace() );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, optimal_workspace() );
}
//
@@ -480,11 +482,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, work );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, work );
}
//
@@ -495,11 +497,11 @@
//
template< typename MatrixAB, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tbrfs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbrfs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b, const MatrixX& x,
const VectorFERR& ferr, const VectorBERR& berr ) {
- return tbrfs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b, x, ferr, berr, optimal_workspace() );
+ return tbrfs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b, x, ferr, berr, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tbtrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -51,14 +51,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const float* ab, const fortran_int_t ldab,
- float* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs, const float* ab,
+ const fortran_int_t ldab, float* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_STBTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+ LAPACK_STBTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, &info );
return info;
}
@@ -67,14 +67,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const double* ab, const fortran_int_t ldab,
- double* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs, const double* ab,
+ const fortran_int_t ldab, double* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_DTBTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+ LAPACK_DTBTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, &info );
return info;
}
@@ -83,15 +83,15 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const std::complex<float>* ab,
- const fortran_int_t ldab, std::complex<float>* b,
- const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs,
+ const std::complex<float>* ab, const fortran_int_t ldab,
+ std::complex<float>* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_CTBTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+ LAPACK_CTBTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, &info );
return info;
}
@@ -100,15 +100,15 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tbtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t kd,
- const fortran_int_t nrhs, const std::complex<double>* ab,
- const fortran_int_t ldab, std::complex<double>* b,
- const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tbtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t kd, const fortran_int_t nrhs,
+ const std::complex<double>* ab, const fortran_int_t ldab,
+ std::complex<double>* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_ZTBTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &kd, &nrhs, ab, &ldab, b, &ldb, &info );
+ LAPACK_ZTBTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab,
+ &ldab, b, &ldb, &info );
return info;
}
@@ -131,8 +131,9 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixAB, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t kd,
+ static std::ptrdiff_t invoke( const fortran_int_t kd,
const MatrixAB& ab, MatrixB& b ) {
+ typedef typename result_of::data_side< MatrixAB >::type uplo;
typedef typename result_of::trans_tag< MatrixAB, order >::type trans;
typedef typename result_of::diag_tag< MatrixAB >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -148,7 +149,7 @@
BOOST_ASSERT( stride_major(ab) >= kd+1 );
BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
size_column_op(ab, trans())) );
- return detail::tbtrs( uplo, trans(), diag(), size_column_op(ab,
+ return detail::tbtrs( uplo(), trans(), diag(), size_column_op(ab,
trans()), kd, size_column(b), begin_value(ab),
stride_major(ab), begin_value(b), stride_major(b) );
}
@@ -170,10 +171,10 @@
// * MatrixB&
//
template< typename MatrixAB, typename MatrixB >
-inline std::ptrdiff_t tbtrs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbtrs( const fortran_int_t kd,
const MatrixAB& ab, MatrixB& b ) {
- return tbtrs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b );
+ return tbtrs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b );
}
//
@@ -181,10 +182,10 @@
// * const MatrixB&
//
template< typename MatrixAB, typename MatrixB >
-inline std::ptrdiff_t tbtrs( const char uplo, const fortran_int_t kd,
+inline std::ptrdiff_t tbtrs( const fortran_int_t kd,
const MatrixAB& ab, const MatrixB& b ) {
- return tbtrs_impl< typename value< MatrixAB >::type >::invoke( uplo,
- kd, ab, b );
+ return tbtrs_impl< typename value< MatrixAB >::type >::invoke( kd,
+ ab, b );
}
} // namespace lapack
Added: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tpcon.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tpcon.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -0,0 +1,325 @@
+//
+// Copyright (c) 2002--2010
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPCON_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPCON_HPP
+
+#include <boost/assert.hpp>
+#include <boost/numeric/bindings/begin.hpp>
+#include <boost/numeric/bindings/data_side.hpp>
+#include <boost/numeric/bindings/detail/array.hpp>
+#include <boost/numeric/bindings/diag_tag.hpp>
+#include <boost/numeric/bindings/is_complex.hpp>
+#include <boost/numeric/bindings/is_mutable.hpp>
+#include <boost/numeric/bindings/is_real.hpp>
+#include <boost/numeric/bindings/lapack/workspace.hpp>
+#include <boost/numeric/bindings/remove_imaginary.hpp>
+#include <boost/numeric/bindings/size.hpp>
+#include <boost/numeric/bindings/stride.hpp>
+#include <boost/numeric/bindings/value.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+//
+// The LAPACK-backend for tpcon is the netlib-compatible backend.
+//
+#include <boost/numeric/bindings/lapack/detail/lapack.h>
+#include <boost/numeric/bindings/lapack/detail/lapack_option.hpp>
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//
+// The detail namespace contains value-type-overloaded functions that
+// dispatch to the appropriate back-end LAPACK-routine.
+//
+namespace detail {
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * float value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tpcon( const char norm, UpLo, Diag,
+ const fortran_int_t n, const float* ap, float& rcond, float* work,
+ fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_STPCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, ap, &rcond, work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * double value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tpcon( const char norm, UpLo, Diag,
+ const fortran_int_t n, const double* ap, double& rcond, double* work,
+ fortran_int_t* iwork ) {
+ fortran_int_t info(0);
+ LAPACK_DTPCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, ap, &rcond, work, iwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<float> value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tpcon( const char norm, UpLo, Diag,
+ const fortran_int_t n, const std::complex<float>* ap, float& rcond,
+ std::complex<float>* work, float* rwork ) {
+ fortran_int_t info(0);
+ LAPACK_CTPCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, ap, &rcond, work, rwork, &info );
+ return info;
+}
+
+//
+// Overloaded function for dispatching to
+// * netlib-compatible LAPACK backend (the default), and
+// * complex<double> value-type.
+//
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t tpcon( const char norm, UpLo, Diag,
+ const fortran_int_t n, const std::complex<double>* ap, double& rcond,
+ std::complex<double>* work, double* rwork ) {
+ fortran_int_t info(0);
+ LAPACK_ZTPCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, ap, &rcond, work, rwork, &info );
+ return info;
+}
+
+} // namespace detail
+
+//
+// Value-type based template class. Use this class if you need a type
+// for dispatching to tpcon.
+//
+template< typename Value, typename Enable = void >
+struct tpcon_impl {};
+
+//
+// This implementation is enabled if Value is a real type.
+//
+template< typename Value >
+struct tpcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK, typename IWORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( size(work.select(fortran_int_t())) >=
+ min_size_iwork( size_column(ap) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::tpcon( norm, uplo(), diag(), size_column(ap),
+ begin_value(ap), rcond, begin_value(work.select(real_type())),
+ begin_value(work.select(fortran_int_t())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< fortran_int_t > tmp_iwork(
+ min_size_iwork( size_column(ap) ) );
+ return invoke( norm, ap, rcond, workspace( tmp_work, tmp_iwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ return invoke( norm, ap, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 3*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array iwork.
+ //
+ static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+//
+// This implementation is enabled if Value is a complex type.
+//
+template< typename Value >
+struct tpcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
+
+ typedef Value value_type;
+ typedef typename remove_imaginary< Value >::type real_type;
+ typedef tag::column_major order;
+
+ //
+ // Static member function for user-defined workspaces, that
+ // * Deduces the required arguments for dispatching to LAPACK, and
+ // * Asserts that most arguments make sense.
+ //
+ template< typename MatrixAP, typename WORK, typename RWORK >
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
+ return detail::tpcon( norm, uplo(), diag(), size_column(ap),
+ begin_value(ap), rcond,
+ begin_value(work.select(value_type())),
+ begin_value(work.select(real_type())) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the minimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member function
+ // * Enables the unblocked algorithm (BLAS level 2)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( norm, ap, rcond, workspace( tmp_work, tmp_rwork ) );
+ }
+
+ //
+ // Static member function that
+ // * Figures out the optimal workspace requirements, and passes
+ // the results to the user-defined workspace overload of the
+ // invoke static member
+ // * Enables the blocked algorithm (BLAS level 3)
+ //
+ template< typename MatrixAP >
+ static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap,
+ real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
+ typedef typename result_of::diag_tag< MatrixAP >::type diag;
+ return invoke( norm, ap, rcond, minimal_workspace() );
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array work.
+ //
+ static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) {
+ return 2*n;
+ }
+
+ //
+ // Static member function that returns the minimum size of
+ // workspace-array rwork.
+ //
+ static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) {
+ return n;
+ }
+};
+
+
+//
+// Functions for direct use. These functions are overloaded for temporaries,
+// so that wrapped types can still be passed and used for write-access. In
+// addition, if applicable, they are overloaded for user-defined workspaces.
+// Calls to these functions are passed to the tpcon_impl classes. In the
+// documentation, most overloads are collapsed to avoid a large number of
+// prototypes which are very similar.
+//
+
+//
+// Overloaded function for tpcon. Its overload differs for
+// * User-defined workspace
+//
+template< typename MatrixAP, typename Workspace >
+inline std::ptrdiff_t tpcon( const char norm, const MatrixAP& ap,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, Workspace work ) {
+ return tpcon_impl< typename value< MatrixAP >::type >::invoke( norm,
+ ap, rcond, work );
+}
+
+//
+// Overloaded function for tpcon. Its overload differs for
+// * Default workspace-type (optimal)
+//
+template< typename MatrixAP >
+inline std::ptrdiff_t tpcon( const char norm, const MatrixAP& ap,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond ) {
+ return tpcon_impl< typename value< MatrixAP >::type >::invoke( norm,
+ ap, rcond, optimal_workspace() );
+}
+
+} // namespace lapack
+} // namespace bindings
+} // namespace numeric
+} // namespace boost
+
+#endif
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tprfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -55,16 +55,15 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tprfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const float* ap,
- const float* b, const fortran_int_t ldb, const float* x,
- const fortran_int_t ldx, float* ferr, float* berr, float* work,
- fortran_int_t* iwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tprfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const float* ap, const float* b,
+ const fortran_int_t ldb, const float* x, const fortran_int_t ldx,
+ float* ferr, float* berr, float* work, fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_STPRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, x, &ldx, ferr, berr, work,
- iwork, &info );
+ LAPACK_STPRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, x, &ldx, ferr, berr, work, iwork, &info );
return info;
}
@@ -73,16 +72,15 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tprfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const double* ap,
- const double* b, const fortran_int_t ldb, const double* x,
- const fortran_int_t ldx, double* ferr, double* berr, double* work,
- fortran_int_t* iwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tprfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const double* ap, const double* b,
+ const fortran_int_t ldb, const double* x, const fortran_int_t ldx,
+ double* ferr, double* berr, double* work, fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_DTPRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, x, &ldx, ferr, berr, work,
- iwork, &info );
+ LAPACK_DTPRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, x, &ldx, ferr, berr, work, iwork, &info );
return info;
}
@@ -91,17 +89,16 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tprfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<float>* ap, const std::complex<float>* b,
- const fortran_int_t ldb, const std::complex<float>* x,
- const fortran_int_t ldx, float* ferr, float* berr,
- std::complex<float>* work, float* rwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tprfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<float>* ap,
+ const std::complex<float>* b, const fortran_int_t ldb,
+ const std::complex<float>* x, const fortran_int_t ldx, float* ferr,
+ float* berr, std::complex<float>* work, float* rwork ) {
fortran_int_t info(0);
- LAPACK_CTPRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, x, &ldx, ferr, berr, work,
- rwork, &info );
+ LAPACK_CTPRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, x, &ldx, ferr, berr, work, rwork, &info );
return info;
}
@@ -110,17 +107,16 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tprfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<double>* ap, const std::complex<double>* b,
- const fortran_int_t ldb, const std::complex<double>* x,
- const fortran_int_t ldx, double* ferr, double* berr,
- std::complex<double>* work, double* rwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tprfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<double>* ap,
+ const std::complex<double>* b, const fortran_int_t ldb,
+ const std::complex<double>* x, const fortran_int_t ldx, double* ferr,
+ double* berr, std::complex<double>* work, double* rwork ) {
fortran_int_t info(0);
- LAPACK_ZTPRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, x, &ldx, ferr, berr, work,
- rwork, &info );
+ LAPACK_ZTPRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, x, &ldx, ferr, berr, work, rwork, &info );
return info;
}
@@ -151,10 +147,10 @@
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename IWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
- IWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -174,20 +170,24 @@
VectorBERR >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(berr) >= size_column(b) );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( n ));
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ min_size_iwork( size_column(ap) ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tprfs( uplo, trans(), diag(), n, size_column(b),
- begin_value(ap), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(real_type())),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::tprfs( uplo(), trans(), diag(), size_column(ap),
+ size_column(b), begin_value(ap), begin_value(b),
+ stride_major(b), begin_value(x), stride_major(x),
+ begin_value(ferr), begin_value(berr),
+ begin_value(work.select(real_type())),
begin_value(work.select(fortran_int_t())) );
}
@@ -200,14 +200,16 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n ) );
- return invoke( uplo, n, ap, b, x, ferr, berr, workspace( tmp_work,
+ min_size_iwork( size_column(ap) ) );
+ return invoke( ap, b, x, ferr, berr, workspace( tmp_work,
tmp_iwork ) );
}
@@ -220,11 +222,12 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
- return invoke( uplo, n, ap, b, x, ferr, berr, minimal_workspace() );
+ return invoke( ap, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -262,10 +265,10 @@
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename RWORK >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK,
- RWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
@@ -281,19 +284,24 @@
MatrixX >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tprfs( uplo, trans(), diag(), n, size_column(b),
- begin_value(ap), begin_value(b), stride_major(b),
- begin_value(x), stride_major(x), begin_value(ferr),
- begin_value(berr), begin_value(work.select(value_type())),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::tprfs( uplo(), trans(), diag(), size_column(ap),
+ size_column(b), begin_value(ap), begin_value(b),
+ stride_major(b), begin_value(x), stride_major(x),
+ begin_value(ferr), begin_value(berr),
+ begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
}
@@ -306,13 +314,16 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( uplo, n, ap, b, x, ferr, berr, workspace( tmp_work,
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( ap, b, x, ferr, berr, workspace( tmp_work,
tmp_rwork ) );
}
@@ -325,11 +336,12 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
- return invoke( uplo, n, ap, b, x, ferr, berr, minimal_workspace() );
+ return invoke( ap, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -367,11 +379,11 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, work );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, work );
}
//
@@ -382,11 +394,10 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, VectorBERR& berr ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, optimal_workspace() );
}
//
@@ -397,11 +408,11 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, work );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, work );
}
//
@@ -412,11 +423,10 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- const VectorFERR& ferr, VectorBERR& berr ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, optimal_workspace() );
}
//
@@ -427,11 +437,11 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, work );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
+ Workspace work ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, work );
}
//
@@ -442,11 +452,10 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- VectorFERR& ferr, const VectorBERR& berr ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, optimal_workspace() );
}
//
@@ -457,11 +466,11 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, work );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
+ Workspace work ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, work );
}
//
@@ -472,11 +481,10 @@
//
template< typename MatrixAP, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t tprfs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b, const MatrixX& x,
- const VectorFERR& ferr, const VectorBERR& berr ) {
- return tprfs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t tprfs( const MatrixAP& ap, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
+ return tprfs_impl< typename value< MatrixAP >::type >::invoke( ap, b,
+ x, ferr, berr, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/tptrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -50,13 +50,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tptrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const float* ap,
- float* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tptrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const float* ap, float* b,
+ const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_STPTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, &info );
+ LAPACK_STPTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, &info );
return info;
}
@@ -65,13 +66,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tptrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const double* ap,
- double* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tptrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const double* ap, double* b,
+ const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_DTPTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, &info );
+ LAPACK_DTPTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, &info );
return info;
}
@@ -80,14 +82,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tptrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<float>* ap, std::complex<float>* b,
- const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tptrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<float>* ap,
+ std::complex<float>* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_CTPTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, &info );
+ LAPACK_CTPTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, &info );
return info;
}
@@ -96,14 +98,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t tptrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<double>* ap, std::complex<double>* b,
- const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t tptrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<double>* ap,
+ std::complex<double>* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_ZTPTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, ap, b, &ldb, &info );
+ LAPACK_ZTPTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b,
+ &ldb, &info );
return info;
}
@@ -126,20 +128,22 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixAP, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, MatrixB& b ) {
+ static std::ptrdiff_t invoke( const MatrixAP& ap, MatrixB& b ) {
+ typedef typename result_of::data_side< MatrixAP >::type uplo;
typedef typename result_of::diag_tag< MatrixAP >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
typename remove_const< typename value<
MatrixB >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixB >::value) );
- BOOST_ASSERT( n >= 0 );
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::tptrs( uplo, trans(), diag(), n, size_column(b),
- begin_value(ap), begin_value(b), stride_major(b) );
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::tptrs( uplo(), trans(), diag(), size_column(ap),
+ size_column(b), begin_value(ap), begin_value(b),
+ stride_major(b) );
}
};
@@ -159,10 +163,9 @@
// * MatrixB&
//
template< typename MatrixAP, typename MatrixB >
-inline std::ptrdiff_t tptrs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, MatrixB& b ) {
- return tptrs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b );
+inline std::ptrdiff_t tptrs( const MatrixAP& ap, MatrixB& b ) {
+ return tptrs_impl< typename value< MatrixAP >::type >::invoke( ap,
+ b );
}
//
@@ -170,10 +173,9 @@
// * const MatrixB&
//
template< typename MatrixAP, typename MatrixB >
-inline std::ptrdiff_t tptrs( const char uplo, const fortran_int_t n,
- const MatrixAP& ap, const MatrixB& b ) {
- return tptrs_impl< typename value< MatrixAP >::type >::invoke( uplo,
- n, ap, b );
+inline std::ptrdiff_t tptrs( const MatrixAP& ap, const MatrixB& b ) {
+ return tptrs_impl< typename value< MatrixAP >::type >::invoke( ap,
+ b );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trcon.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -54,13 +54,13 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t trcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t trcon( const char norm, UpLo, Diag,
const fortran_int_t n, const float* a, const fortran_int_t lda,
float& rcond, float* work, fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_STRCON( &norm, &uplo, &lapack_option< Diag >::value, &n, a, &lda,
- &rcond, work, iwork, &info );
+ LAPACK_STRCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, a, &lda, &rcond, work, iwork, &info );
return info;
}
@@ -69,13 +69,13 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t trcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t trcon( const char norm, UpLo, Diag,
const fortran_int_t n, const double* a, const fortran_int_t lda,
double& rcond, double* work, fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_DTRCON( &norm, &uplo, &lapack_option< Diag >::value, &n, a, &lda,
- &rcond, work, iwork, &info );
+ LAPACK_DTRCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, a, &lda, &rcond, work, iwork, &info );
return info;
}
@@ -84,14 +84,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t trcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t trcon( const char norm, UpLo, Diag,
const fortran_int_t n, const std::complex<float>* a,
const fortran_int_t lda, float& rcond, std::complex<float>* work,
float* rwork ) {
fortran_int_t info(0);
- LAPACK_CTRCON( &norm, &uplo, &lapack_option< Diag >::value, &n, a, &lda,
- &rcond, work, rwork, &info );
+ LAPACK_CTRCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, a, &lda, &rcond, work, rwork, &info );
return info;
}
@@ -100,14 +100,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Diag >
-inline std::ptrdiff_t trcon( const char norm, const char uplo, Diag,
+template< typename UpLo, typename Diag >
+inline std::ptrdiff_t trcon( const char norm, UpLo, Diag,
const fortran_int_t n, const std::complex<double>* a,
const fortran_int_t lda, double& rcond, std::complex<double>* work,
double* rwork ) {
fortran_int_t info(0);
- LAPACK_ZTRCON( &norm, &uplo, &lapack_option< Diag >::value, &n, a, &lda,
- &rcond, work, rwork, &info );
+ LAPACK_ZTRCON( &norm, &lapack_option< UpLo >::value, &lapack_option<
+ Diag >::value, &n, a, &lda, &rcond, work, rwork, &info );
return info;
}
@@ -136,9 +136,9 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixA, typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const MatrixA& a, real_type& rcond, detail::workspace2< WORK,
- IWORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ real_type& rcond, detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
@@ -149,7 +149,7 @@
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
size_column(a)) );
- return detail::trcon( norm, uplo, diag(), size_column(a),
+ return detail::trcon( norm, uplo(), diag(), size_column(a),
begin_value(a), stride_major(a), rcond,
begin_value(work.select(real_type())),
begin_value(work.select(fortran_int_t())) );
@@ -163,15 +163,15 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixA >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const MatrixA& a, real_type& rcond, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column(a) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( size_column(a) ) );
- return invoke( norm, uplo, a, rcond, workspace( tmp_work,
- tmp_iwork ) );
+ return invoke( norm, a, rcond, workspace( tmp_work, tmp_iwork ) );
}
//
@@ -182,10 +182,11 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixA >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const MatrixA& a, real_type& rcond, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
- return invoke( norm, uplo, a, rcond, minimal_workspace() );
+ return invoke( norm, a, rcond, minimal_workspace() );
}
//
@@ -221,9 +222,9 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixA, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const MatrixA& a, real_type& rcond, detail::workspace2< WORK,
- RWORK > work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ real_type& rcond, detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
@@ -234,7 +235,7 @@
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
size_column(a)) );
- return detail::trcon( norm, uplo, diag(), size_column(a),
+ return detail::trcon( norm, uplo(), diag(), size_column(a),
begin_value(a), stride_major(a), rcond,
begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
@@ -248,15 +249,15 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixA >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const MatrixA& a, real_type& rcond, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ real_type& rcond, minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column(a) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
size_column(a) ) );
- return invoke( norm, uplo, a, rcond, workspace( tmp_work,
- tmp_rwork ) );
+ return invoke( norm, a, rcond, workspace( tmp_work, tmp_rwork ) );
}
//
@@ -267,10 +268,11 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixA >
- static std::ptrdiff_t invoke( const char norm, const char uplo,
- const MatrixA& a, real_type& rcond, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
+ real_type& rcond, optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::diag_tag< MatrixA >::type diag;
- return invoke( norm, uplo, a, rcond, minimal_workspace() );
+ return invoke( norm, a, rcond, minimal_workspace() );
}
//
@@ -305,11 +307,11 @@
// * User-defined workspace
//
template< typename MatrixA, typename Workspace >
-inline std::ptrdiff_t trcon( const char norm, const char uplo,
- const MatrixA& a, typename remove_imaginary< typename value<
+inline std::ptrdiff_t trcon( const char norm, const MatrixA& a,
+ typename remove_imaginary< typename value<
MatrixA >::type >::type& rcond, Workspace work ) {
return trcon_impl< typename value< MatrixA >::type >::invoke( norm,
- uplo, a, rcond, work );
+ a, rcond, work );
}
//
@@ -317,11 +319,11 @@
// * Default workspace-type (optimal)
//
template< typename MatrixA >
-inline std::ptrdiff_t trcon( const char norm, const char uplo,
- const MatrixA& a, typename remove_imaginary< typename value<
+inline std::ptrdiff_t trcon( const char norm, const MatrixA& a,
+ typename remove_imaginary< typename value<
MatrixA >::type >::type& rcond ) {
return trcon_impl< typename value< MatrixA >::type >::invoke( norm,
- uplo, a, rcond, optimal_workspace() );
+ a, rcond, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trrfs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -55,16 +55,16 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const float* a,
- const fortran_int_t lda, const float* b, const fortran_int_t ldb,
- const float* x, const fortran_int_t ldx, float* ferr, float* berr,
- float* work, fortran_int_t* iwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const float* a, const fortran_int_t lda,
+ const float* b, const fortran_int_t ldb, const float* x,
+ const fortran_int_t ldx, float* ferr, float* berr, float* work,
+ fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_STRRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, x, &ldx, ferr, berr,
- work, iwork, &info );
+ LAPACK_STRRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
return info;
}
@@ -73,16 +73,16 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const double* a,
- const fortran_int_t lda, const double* b, const fortran_int_t ldb,
- const double* x, const fortran_int_t ldx, double* ferr, double* berr,
- double* work, fortran_int_t* iwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const double* a, const fortran_int_t lda,
+ const double* b, const fortran_int_t ldb, const double* x,
+ const fortran_int_t ldx, double* ferr, double* berr, double* work,
+ fortran_int_t* iwork ) {
fortran_int_t info(0);
- LAPACK_DTRRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, x, &ldx, ferr, berr,
- work, iwork, &info );
+ LAPACK_DTRRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, x, &ldx, ferr, berr, work, iwork, &info );
return info;
}
@@ -91,17 +91,17 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<float>* a, const fortran_int_t lda,
- const std::complex<float>* b, const fortran_int_t ldb,
- const std::complex<float>* x, const fortran_int_t ldx, float* ferr,
- float* berr, std::complex<float>* work, float* rwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<float>* a,
+ const fortran_int_t lda, const std::complex<float>* b,
+ const fortran_int_t ldb, const std::complex<float>* x,
+ const fortran_int_t ldx, float* ferr, float* berr,
+ std::complex<float>* work, float* rwork ) {
fortran_int_t info(0);
- LAPACK_CTRRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, x, &ldx, ferr, berr,
- work, rwork, &info );
+ LAPACK_CTRRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, x, &ldx, ferr, berr, work, rwork, &info );
return info;
}
@@ -110,17 +110,17 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trrfs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<double>* a, const fortran_int_t lda,
- const std::complex<double>* b, const fortran_int_t ldb,
- const std::complex<double>* x, const fortran_int_t ldx, double* ferr,
- double* berr, std::complex<double>* work, double* rwork ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trrfs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<double>* a,
+ const fortran_int_t lda, const std::complex<double>* b,
+ const fortran_int_t ldb, const std::complex<double>* x,
+ const fortran_int_t ldx, double* ferr, double* berr,
+ std::complex<double>* work, double* rwork ) {
fortran_int_t info(0);
- LAPACK_ZTRRFS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, x, &ldx, ferr, berr,
- work, rwork, &info );
+ LAPACK_ZTRRFS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, x, &ldx, ferr, berr, work, rwork, &info );
return info;
}
@@ -151,9 +151,10 @@
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename IWORK >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, detail::workspace2< WORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, IWORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -190,7 +191,7 @@
size_column_op(a, trans())) );
BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
size_column_op(a, trans())) );
- return detail::trrfs( uplo, trans(), diag(), size_column_op(a,
+ return detail::trrfs( uplo(), trans(), diag(), size_column_op(a,
trans()), size_column(b), begin_value(a), stride_major(a),
begin_value(b), stride_major(b), begin_value(x),
stride_major(x), begin_value(ferr), begin_value(berr),
@@ -207,17 +208,17 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
bindings::detail::array< real_type > tmp_work( min_size_work(
size_column_op(a, trans()) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
min_size_iwork( size_column_op(a, trans()) ) );
- return invoke( uplo, a, b, x, ferr, berr, workspace( tmp_work,
- tmp_iwork ) );
+ return invoke( a, b, x, ferr, berr, workspace( tmp_work, tmp_iwork ) );
}
//
@@ -229,12 +230,13 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
- return invoke( uplo, a, b, x, ferr, berr, minimal_workspace() );
+ return invoke( a, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -272,9 +274,10 @@
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename WORK,
typename RWORK >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, RWORK > work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -307,7 +310,7 @@
size_column_op(a, trans())) );
BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
size_column_op(a, trans())) );
- return detail::trrfs( uplo, trans(), diag(), size_column_op(a,
+ return detail::trrfs( uplo(), trans(), diag(), size_column_op(a,
trans()), size_column(b), begin_value(a), stride_major(a),
begin_value(b), stride_major(b), begin_value(x),
stride_major(x), begin_value(ferr), begin_value(berr),
@@ -324,17 +327,17 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
bindings::detail::array< value_type > tmp_work( min_size_work(
size_column_op(a, trans()) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
size_column_op(a, trans()) ) );
- return invoke( uplo, a, b, x, ferr, berr, workspace( tmp_work,
- tmp_rwork ) );
+ return invoke( a, b, x, ferr, berr, workspace( tmp_work, tmp_rwork ) );
}
//
@@ -346,12 +349,13 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
- return invoke( uplo, a, b, x, ferr, berr, minimal_workspace() );
+ return invoke( a, b, x, ferr, berr, minimal_workspace() );
}
//
@@ -389,11 +393,11 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, work );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, work );
}
//
@@ -404,11 +408,10 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- VectorBERR& berr ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, optimal_workspace() );
}
//
@@ -419,11 +422,11 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, work );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, work );
}
//
@@ -434,11 +437,10 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- VectorBERR& berr ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, VectorBERR& berr ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, optimal_workspace() );
}
//
@@ -449,11 +451,11 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, work );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr,
+ Workspace work ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, work );
}
//
@@ -464,11 +466,10 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, VectorFERR& ferr,
- const VectorBERR& berr ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, VectorFERR& ferr, const VectorBERR& berr ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, optimal_workspace() );
}
//
@@ -479,11 +480,11 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr, Workspace work ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, work );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr,
+ Workspace work ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, work );
}
//
@@ -494,11 +495,10 @@
//
template< typename MatrixA, typename MatrixB, typename MatrixX,
typename VectorFERR, typename VectorBERR >
-inline std::ptrdiff_t trrfs( const char uplo, const MatrixA& a,
- const MatrixB& b, const MatrixX& x, const VectorFERR& ferr,
- const VectorBERR& berr ) {
- return trrfs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b, x, ferr, berr, optimal_workspace() );
+inline std::ptrdiff_t trrfs( const MatrixA& a, const MatrixB& b,
+ const MatrixX& x, const VectorFERR& ferr, const VectorBERR& berr ) {
+ return trrfs_impl< typename value< MatrixA >::type >::invoke( a, b,
+ x, ferr, berr, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/trtrs.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -50,13 +50,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * float value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const float* a,
- const fortran_int_t lda, float* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const float* a, const fortran_int_t lda,
+ float* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_STRTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, &info );
+ LAPACK_STRTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, &info );
return info;
}
@@ -65,13 +66,14 @@
// * netlib-compatible LAPACK backend (the default), and
// * double value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs, const double* a,
- const fortran_int_t lda, double* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const double* a, const fortran_int_t lda,
+ double* b, const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_DTRTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, &info );
+ LAPACK_DTRTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, &info );
return info;
}
@@ -80,14 +82,15 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<float> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<float>* a, const fortran_int_t lda,
- std::complex<float>* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<float>* a,
+ const fortran_int_t lda, std::complex<float>* b,
+ const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_CTRTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, &info );
+ LAPACK_CTRTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, &info );
return info;
}
@@ -96,14 +99,15 @@
// * netlib-compatible LAPACK backend (the default), and
// * complex<double> value-type.
//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t trtrs( const char uplo, Trans, Diag,
- const fortran_int_t n, const fortran_int_t nrhs,
- const std::complex<double>* a, const fortran_int_t lda,
- std::complex<double>* b, const fortran_int_t ldb ) {
+template< typename UpLo, typename Trans, typename Diag >
+inline std::ptrdiff_t trtrs( UpLo, Trans, Diag, const fortran_int_t n,
+ const fortran_int_t nrhs, const std::complex<double>* a,
+ const fortran_int_t lda, std::complex<double>* b,
+ const fortran_int_t ldb ) {
fortran_int_t info(0);
- LAPACK_ZTRTRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &n, &nrhs, a, &lda, b, &ldb, &info );
+ LAPACK_ZTRTRS( &lapack_option< UpLo >::value, &lapack_option<
+ Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda,
+ b, &ldb, &info );
return info;
}
@@ -126,8 +130,8 @@
// * Asserts that most arguments make sense.
//
template< typename MatrixA, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo, const MatrixA& a,
- MatrixB& b ) {
+ static std::ptrdiff_t invoke( const MatrixA& a, MatrixB& b ) {
+ typedef typename result_of::data_side< MatrixA >::type uplo;
typedef typename result_of::trans_tag< MatrixA, order >::type trans;
typedef typename result_of::diag_tag< MatrixA >::type diag;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
@@ -143,7 +147,7 @@
size_column_op(a, trans())) );
BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
size_column_op(a, trans())) );
- return detail::trtrs( uplo, trans(), diag(), size_column_op(a,
+ return detail::trtrs( uplo(), trans(), diag(), size_column_op(a,
trans()), size_column(b), begin_value(a), stride_major(a),
begin_value(b), stride_major(b) );
}
@@ -165,10 +169,8 @@
// * MatrixB&
//
template< typename MatrixA, typename MatrixB >
-inline std::ptrdiff_t trtrs( const char uplo, const MatrixA& a,
- MatrixB& b ) {
- return trtrs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b );
+inline std::ptrdiff_t trtrs( const MatrixA& a, MatrixB& b ) {
+ return trtrs_impl< typename value< MatrixA >::type >::invoke( a, b );
}
//
@@ -176,10 +178,8 @@
// * const MatrixB&
//
template< typename MatrixA, typename MatrixB >
-inline std::ptrdiff_t trtrs( const char uplo, const MatrixA& a,
- const MatrixB& b ) {
- return trtrs_impl< typename value< MatrixA >::type >::invoke( uplo,
- a, b );
+inline std::ptrdiff_t trtrs( const MatrixA& a, const MatrixB& b ) {
+ return trtrs_impl< typename value< MatrixA >::type >::invoke( a, b );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/unglq.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -100,7 +100,6 @@
typename remove_const< typename value<
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( k >= k );
BOOST_ASSERT( m >= 0 );
BOOST_ASSERT( n >= m );
BOOST_ASSERT( size(tau) >= k );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungql.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -100,9 +100,7 @@
typename remove_const< typename value<
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( k >= k );
BOOST_ASSERT( m >= 0 );
- BOOST_ASSERT( n >= n );
BOOST_ASSERT( size(tau) >= k );
BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungqr.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -100,10 +100,8 @@
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
BOOST_ASSERT( size(tau) >= size(tau) );
- BOOST_ASSERT( size(tau) >= size(tau) );
BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
size_column(a) ));
- BOOST_ASSERT( size_column(a) >= size_column(a) );
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
BOOST_ASSERT( size_row(a) >= 0 );
BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/ungrq.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -100,7 +100,6 @@
typename remove_const< typename value<
VectorTAU >::type >::type >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixA >::value) );
- BOOST_ASSERT( k >= k );
BOOST_ASSERT( m >= 0 );
BOOST_ASSERT( n >= m );
BOOST_ASSERT( size(tau) >= k );
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -1129,6 +1129,14 @@
const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb,
fortran_int_t* info );
+// Value-type variants of hpcon
+void LAPACK_CHPCON( const char* uplo, const fortran_int_t* n, const void* ap,
+ const fortran_int_t* ipiv, const float* anorm, float* rcond,
+ void* work, fortran_int_t* info );
+void LAPACK_ZHPCON( const char* uplo, const fortran_int_t* n, const void* ap,
+ const fortran_int_t* ipiv, const double* anorm, double* rcond,
+ void* work, fortran_int_t* info );
+
// Value-type variants of hprfs
void LAPACK_CHPRFS( const char* uplo, const fortran_int_t* n,
const fortran_int_t* nrhs, const void* ap, const void* afp,
@@ -1147,6 +1155,12 @@
void LAPACK_ZHPTRF( const char* uplo, const fortran_int_t* n, void* ap,
fortran_int_t* ipiv, fortran_int_t* info );
+// Value-type variants of hptri
+void LAPACK_CHPTRI( const char* uplo, const fortran_int_t* n, void* ap,
+ const fortran_int_t* ipiv, void* work, fortran_int_t* info );
+void LAPACK_ZHPTRI( const char* uplo, const fortran_int_t* n, void* ap,
+ const fortran_int_t* ipiv, void* work, fortran_int_t* info );
+
// Value-type variants of hptrs
void LAPACK_CHPTRS( const char* uplo, const fortran_int_t* n,
const fortran_int_t* nrhs, const void* ap, const fortran_int_t* ipiv,
@@ -1273,26 +1287,6 @@
const fortran_int_t* ldab, void* b, const fortran_int_t* ldb,
fortran_int_t* info );
-// Value-type variants of pftrf
-void LAPACK_SPFTRF( const char* transr, const char* uplo,
- const fortran_int_t* n, float* a, fortran_int_t* info );
-void LAPACK_DPFTRF( const char* transr, const char* uplo,
- const fortran_int_t* n, double* a, fortran_int_t* info );
-void LAPACK_CPFTRF( const char* transr, const char* uplo,
- const fortran_int_t* n, void* a, fortran_int_t* info );
-void LAPACK_ZPFTRF( const char* transr, const char* uplo,
- const fortran_int_t* n, void* a, fortran_int_t* info );
-
-// Value-type variants of pftri
-void LAPACK_SPFTRI( const char* transr, const char* uplo,
- const fortran_int_t* n, float* a, fortran_int_t* info );
-void LAPACK_DPFTRI( const char* transr, const char* uplo,
- const fortran_int_t* n, double* a, fortran_int_t* info );
-void LAPACK_CPFTRI( const char* transr, const char* uplo,
- const fortran_int_t* n, void* a, fortran_int_t* info );
-void LAPACK_ZPFTRI( const char* transr, const char* uplo,
- const fortran_int_t* n, void* a, fortran_int_t* info );
-
// Value-type variants of pftrs
void LAPACK_SPFTRS( const char* transr, const char* uplo,
const fortran_int_t* n, const fortran_int_t* nrhs, const float* a,
@@ -1395,6 +1389,31 @@
const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda,
void* b, const fortran_int_t* ldb, fortran_int_t* info );
+// Value-type variants of ppcon
+void LAPACK_SPPCON( const char* uplo, const fortran_int_t* n, const float* ap,
+ const float* anorm, float* rcond, float* work, fortran_int_t* iwork,
+ fortran_int_t* info );
+void LAPACK_DPPCON( const char* uplo, const fortran_int_t* n,
+ const double* ap, const double* anorm, double* rcond, double* work,
+ fortran_int_t* iwork, fortran_int_t* info );
+void LAPACK_CPPCON( const char* uplo, const fortran_int_t* n, const void* ap,
+ const float* anorm, float* rcond, void* work, float* rwork,
+ fortran_int_t* info );
+void LAPACK_ZPPCON( const char* uplo, const fortran_int_t* n, const void* ap,
+ const double* anorm, double* rcond, void* work, double* rwork,
+ fortran_int_t* info );
+
+// Value-type variants of ppequ
+void LAPACK_SPPEQU( const char* uplo, const fortran_int_t* n, const float* ap,
+ float* s, float* scond, float* amax, fortran_int_t* info );
+void LAPACK_DPPEQU( const char* uplo, const fortran_int_t* n,
+ const double* ap, double* s, double* scond, double* amax,
+ fortran_int_t* info );
+void LAPACK_CPPEQU( const char* uplo, const fortran_int_t* n, const void* ap,
+ float* s, float* scond, float* amax, fortran_int_t* info );
+void LAPACK_ZPPEQU( const char* uplo, const fortran_int_t* n, const void* ap,
+ double* s, double* scond, double* amax, fortran_int_t* info );
+
// Value-type variants of pprfs
void LAPACK_SPPRFS( const char* uplo, const fortran_int_t* n,
const fortran_int_t* nrhs, const float* ap, const float* afp,
@@ -1427,6 +1446,16 @@
void LAPACK_ZPPTRF( const char* uplo, const fortran_int_t* n, void* ap,
fortran_int_t* info );
+// Value-type variants of pptri
+void LAPACK_SPPTRI( const char* uplo, const fortran_int_t* n, float* ap,
+ fortran_int_t* info );
+void LAPACK_DPPTRI( const char* uplo, const fortran_int_t* n, double* ap,
+ fortran_int_t* info );
+void LAPACK_CPPTRI( const char* uplo, const fortran_int_t* n, void* ap,
+ fortran_int_t* info );
+void LAPACK_ZPPTRI( const char* uplo, const fortran_int_t* n, void* ap,
+ fortran_int_t* info );
+
// Value-type variants of pptrs
void LAPACK_SPPTRS( const char* uplo, const fortran_int_t* n,
const fortran_int_t* nrhs, const float* ap, float* b,
@@ -1479,6 +1508,21 @@
const fortran_int_t* nrhs, const double* d, const void* e, void* b,
const fortran_int_t* ldb, fortran_int_t* info );
+// Value-type variants of spcon
+void LAPACK_SSPCON( const char* uplo, const fortran_int_t* n, const float* ap,
+ const fortran_int_t* ipiv, const float* anorm, float* rcond,
+ float* work, fortran_int_t* iwork, fortran_int_t* info );
+void LAPACK_DSPCON( const char* uplo, const fortran_int_t* n,
+ const double* ap, const fortran_int_t* ipiv, const double* anorm,
+ double* rcond, double* work, fortran_int_t* iwork,
+ fortran_int_t* info );
+void LAPACK_CSPCON( const char* uplo, const fortran_int_t* n, const void* ap,
+ const fortran_int_t* ipiv, const float* anorm, float* rcond,
+ void* work, fortran_int_t* info );
+void LAPACK_ZSPCON( const char* uplo, const fortran_int_t* n, const void* ap,
+ const fortran_int_t* ipiv, const double* anorm, double* rcond,
+ void* work, fortran_int_t* info );
+
// Value-type variants of sprfs
void LAPACK_SSPRFS( const char* uplo, const fortran_int_t* n,
const fortran_int_t* nrhs, const float* ap, const float* afp,
@@ -1511,6 +1555,16 @@
void LAPACK_ZSPTRF( const char* uplo, const fortran_int_t* n, void* ap,
fortran_int_t* ipiv, fortran_int_t* info );
+// Value-type variants of sptri
+void LAPACK_SSPTRI( const char* uplo, const fortran_int_t* n, float* ap,
+ const fortran_int_t* ipiv, float* work, fortran_int_t* info );
+void LAPACK_DSPTRI( const char* uplo, const fortran_int_t* n, double* ap,
+ const fortran_int_t* ipiv, double* work, fortran_int_t* info );
+void LAPACK_CSPTRI( const char* uplo, const fortran_int_t* n, void* ap,
+ const fortran_int_t* ipiv, void* work, fortran_int_t* info );
+void LAPACK_ZSPTRI( const char* uplo, const fortran_int_t* n, void* ap,
+ const fortran_int_t* ipiv, void* work, fortran_int_t* info );
+
// Value-type variants of sptrs
void LAPACK_SSPTRS( const char* uplo, const fortran_int_t* n,
const fortran_int_t* nrhs, const float* ap, const fortran_int_t* ipiv,
@@ -1677,15 +1731,19 @@
const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab,
void* b, const fortran_int_t* ldb, fortran_int_t* info );
-// Value-type variants of tftri
-void LAPACK_STFTRI( const char* transr, const char* uplo, const char* diag,
- const fortran_int_t* n, float* a, fortran_int_t* info );
-void LAPACK_DTFTRI( const char* transr, const char* uplo, const char* diag,
- const fortran_int_t* n, double* a, fortran_int_t* info );
-void LAPACK_CTFTRI( const char* transr, const char* uplo, const char* diag,
- const fortran_int_t* n, void* a, fortran_int_t* info );
-void LAPACK_ZTFTRI( const char* transr, const char* uplo, const char* diag,
- const fortran_int_t* n, void* a, fortran_int_t* info );
+// Value-type variants of tpcon
+void LAPACK_STPCON( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const float* ap, float* rcond, float* work,
+ fortran_int_t* iwork, fortran_int_t* info );
+void LAPACK_DTPCON( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const double* ap, double* rcond, double* work,
+ fortran_int_t* iwork, fortran_int_t* info );
+void LAPACK_CTPCON( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const void* ap, float* rcond, void* work,
+ float* rwork, fortran_int_t* info );
+void LAPACK_ZTPCON( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const void* ap, double* rcond, void* work,
+ double* rwork, fortran_int_t* info );
// Value-type variants of tprfs
void LAPACK_STPRFS( const char* uplo, const char* trans, const char* diag,
@@ -1820,6 +1878,12 @@
const fortran_int_t* lda, double* d, double* e, void* tau, void* work,
const fortran_int_t* lwork, fortran_int_t* info );
+// Value-type variants of hptrd
+void LAPACK_CHPTRD( const char* uplo, const fortran_int_t* n, void* ap,
+ float* d, float* e, void* tau, fortran_int_t* info );
+void LAPACK_ZHPTRD( const char* uplo, const fortran_int_t* n, void* ap,
+ double* d, double* e, void* tau, fortran_int_t* info );
+
// Value-type variants of laebz
void LAPACK_SLAEBZ( const fortran_int_t* ijob, const fortran_int_t* nitmax,
const fortran_int_t* n, const fortran_int_t* mmax,
@@ -1913,6 +1977,12 @@
const fortran_int_t* ldab, double* d, double* e, double* q,
const fortran_int_t* ldq, double* work, fortran_int_t* info );
+// Value-type variants of sptrd
+void LAPACK_SSPTRD( const char* uplo, const fortran_int_t* n, float* ap,
+ float* d, float* e, float* tau, fortran_int_t* info );
+void LAPACK_DSPTRD( const char* uplo, const fortran_int_t* n, double* ap,
+ double* d, double* e, double* tau, fortran_int_t* info );
+
// Value-type variants of stebz
void LAPACK_SSTEBZ( const char* range, const char* order,
const fortran_int_t* n, const float* vl, const float* vu,
@@ -4206,6 +4276,16 @@
const fortran_int_t* n, const fortran_int_t* k, const void* ab,
const fortran_int_t* ldab, double* work );
+// Value-type variants of lantp
+void LAPACK_SLANTP( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const float* ap, float* work );
+void LAPACK_DLANTP( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const double* ap, double* work );
+void LAPACK_CLANTP( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const void* ap, float* work );
+void LAPACK_ZLANTP( const char* norm, const char* uplo, const char* diag,
+ const fortran_int_t* n, const void* ap, double* work );
+
// Value-type variants of lantr
void LAPACK_SLANTR( const char* norm, const char* uplo, const char* diag,
const fortran_int_t* m, const fortran_int_t* n, const float* a,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -394,6 +394,10 @@
#define LAPACK_CHETRS FORTRAN_ID( chetrs )
#define LAPACK_ZHETRS FORTRAN_ID( zhetrs )
+// Value-type variants of hpcon
+#define LAPACK_CHPCON FORTRAN_ID( chpcon )
+#define LAPACK_ZHPCON FORTRAN_ID( zhpcon )
+
// Value-type variants of hprfs
#define LAPACK_CHPRFS FORTRAN_ID( chprfs )
#define LAPACK_ZHPRFS FORTRAN_ID( zhprfs )
@@ -402,6 +406,10 @@
#define LAPACK_CHPTRF FORTRAN_ID( chptrf )
#define LAPACK_ZHPTRF FORTRAN_ID( zhptrf )
+// Value-type variants of hptri
+#define LAPACK_CHPTRI FORTRAN_ID( chptri )
+#define LAPACK_ZHPTRI FORTRAN_ID( zhptri )
+
// Value-type variants of hptrs
#define LAPACK_CHPTRS FORTRAN_ID( chptrs )
#define LAPACK_ZHPTRS FORTRAN_ID( zhptrs )
@@ -448,18 +456,6 @@
#define LAPACK_CPBTRS FORTRAN_ID( cpbtrs )
#define LAPACK_ZPBTRS FORTRAN_ID( zpbtrs )
-// Value-type variants of pftrf
-#define LAPACK_SPFTRF FORTRAN_ID( spftrf )
-#define LAPACK_DPFTRF FORTRAN_ID( dpftrf )
-#define LAPACK_CPFTRF FORTRAN_ID( cpftrf )
-#define LAPACK_ZPFTRF FORTRAN_ID( zpftrf )
-
-// Value-type variants of pftri
-#define LAPACK_SPFTRI FORTRAN_ID( spftri )
-#define LAPACK_DPFTRI FORTRAN_ID( dpftri )
-#define LAPACK_CPFTRI FORTRAN_ID( cpftri )
-#define LAPACK_ZPFTRI FORTRAN_ID( zpftri )
-
// Value-type variants of pftrs
#define LAPACK_SPFTRS FORTRAN_ID( spftrs )
#define LAPACK_DPFTRS FORTRAN_ID( dpftrs )
@@ -502,6 +498,18 @@
#define LAPACK_CPOTRS FORTRAN_ID( cpotrs )
#define LAPACK_ZPOTRS FORTRAN_ID( zpotrs )
+// Value-type variants of ppcon
+#define LAPACK_SPPCON FORTRAN_ID( sppcon )
+#define LAPACK_DPPCON FORTRAN_ID( dppcon )
+#define LAPACK_CPPCON FORTRAN_ID( cppcon )
+#define LAPACK_ZPPCON FORTRAN_ID( zppcon )
+
+// Value-type variants of ppequ
+#define LAPACK_SPPEQU FORTRAN_ID( sppequ )
+#define LAPACK_DPPEQU FORTRAN_ID( dppequ )
+#define LAPACK_CPPEQU FORTRAN_ID( cppequ )
+#define LAPACK_ZPPEQU FORTRAN_ID( zppequ )
+
// Value-type variants of pprfs
#define LAPACK_SPPRFS FORTRAN_ID( spprfs )
#define LAPACK_DPPRFS FORTRAN_ID( dpprfs )
@@ -514,6 +522,12 @@
#define LAPACK_CPPTRF FORTRAN_ID( cpptrf )
#define LAPACK_ZPPTRF FORTRAN_ID( zpptrf )
+// Value-type variants of pptri
+#define LAPACK_SPPTRI FORTRAN_ID( spptri )
+#define LAPACK_DPPTRI FORTRAN_ID( dpptri )
+#define LAPACK_CPPTRI FORTRAN_ID( cpptri )
+#define LAPACK_ZPPTRI FORTRAN_ID( zpptri )
+
// Value-type variants of pptrs
#define LAPACK_SPPTRS FORTRAN_ID( spptrs )
#define LAPACK_DPPTRS FORTRAN_ID( dpptrs )
@@ -532,6 +546,12 @@
#define LAPACK_CPTTRS FORTRAN_ID( cpttrs )
#define LAPACK_ZPTTRS FORTRAN_ID( zpttrs )
+// Value-type variants of spcon
+#define LAPACK_SSPCON FORTRAN_ID( sspcon )
+#define LAPACK_DSPCON FORTRAN_ID( dspcon )
+#define LAPACK_CSPCON FORTRAN_ID( cspcon )
+#define LAPACK_ZSPCON FORTRAN_ID( zspcon )
+
// Value-type variants of sprfs
#define LAPACK_SSPRFS FORTRAN_ID( ssprfs )
#define LAPACK_DSPRFS FORTRAN_ID( dsprfs )
@@ -544,6 +564,12 @@
#define LAPACK_CSPTRF FORTRAN_ID( csptrf )
#define LAPACK_ZSPTRF FORTRAN_ID( zsptrf )
+// Value-type variants of sptri
+#define LAPACK_SSPTRI FORTRAN_ID( ssptri )
+#define LAPACK_DSPTRI FORTRAN_ID( dsptri )
+#define LAPACK_CSPTRI FORTRAN_ID( csptri )
+#define LAPACK_ZSPTRI FORTRAN_ID( zsptri )
+
// Value-type variants of sptrs
#define LAPACK_SSPTRS FORTRAN_ID( ssptrs )
#define LAPACK_DSPTRS FORTRAN_ID( dsptrs )
@@ -598,11 +624,11 @@
#define LAPACK_CTBTRS FORTRAN_ID( ctbtrs )
#define LAPACK_ZTBTRS FORTRAN_ID( ztbtrs )
-// Value-type variants of tftri
-#define LAPACK_STFTRI FORTRAN_ID( stftri )
-#define LAPACK_DTFTRI FORTRAN_ID( dtftri )
-#define LAPACK_CTFTRI FORTRAN_ID( ctftri )
-#define LAPACK_ZTFTRI FORTRAN_ID( ztftri )
+// Value-type variants of tpcon
+#define LAPACK_STPCON FORTRAN_ID( stpcon )
+#define LAPACK_DTPCON FORTRAN_ID( dtpcon )
+#define LAPACK_CTPCON FORTRAN_ID( ctpcon )
+#define LAPACK_ZTPCON FORTRAN_ID( ztpcon )
// Value-type variants of tprfs
#define LAPACK_STPRFS FORTRAN_ID( stprfs )
@@ -654,6 +680,10 @@
#define LAPACK_CHETRD FORTRAN_ID( chetrd )
#define LAPACK_ZHETRD FORTRAN_ID( zhetrd )
+// Value-type variants of hptrd
+#define LAPACK_CHPTRD FORTRAN_ID( chptrd )
+#define LAPACK_ZHPTRD FORTRAN_ID( zhptrd )
+
// Value-type variants of laebz
#define LAPACK_SLAEBZ FORTRAN_ID( slaebz )
#define LAPACK_DLAEBZ FORTRAN_ID( dlaebz )
@@ -690,6 +720,10 @@
#define LAPACK_SSBTRD FORTRAN_ID( ssbtrd )
#define LAPACK_DSBTRD FORTRAN_ID( dsbtrd )
+// Value-type variants of sptrd
+#define LAPACK_SSPTRD FORTRAN_ID( ssptrd )
+#define LAPACK_DSPTRD FORTRAN_ID( dsptrd )
+
// Value-type variants of stebz
#define LAPACK_SSTEBZ FORTRAN_ID( sstebz )
#define LAPACK_DSTEBZ FORTRAN_ID( dstebz )
@@ -1358,6 +1392,12 @@
#define LAPACK_CLANTB FORTRAN_ID( clantb )
#define LAPACK_ZLANTB FORTRAN_ID( zlantb )
+// Value-type variants of lantp
+#define LAPACK_SLANTP FORTRAN_ID( slantp )
+#define LAPACK_DLANTP FORTRAN_ID( dlantp )
+#define LAPACK_CLANTP FORTRAN_ID( clantp )
+#define LAPACK_ZLANTP FORTRAN_ID( zlantp )
+
// Value-type variants of lantr
#define LAPACK_SLANTR FORTRAN_ID( slantr )
#define LAPACK_DLANTR FORTRAN_ID( dlantr )
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/gejsv.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -113,7 +113,6 @@
min_size_v( $CALL_MIN_SIZE ));
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
$CALL_MIN_SIZE ));
- BOOST_ASSERT( size_column(a) >= size_column(a) );
BOOST_ASSERT( size_minor(a) == 1 || stride_minor(a) == 1 );
BOOST_ASSERT( size_row(a) >= 0 );
BOOST_ASSERT( stride_major(a) >= std::max< std::ptrdiff_t >(1,
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpev.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -95,9 +95,8 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, detail::workspace2< WORK,
- RWORK > work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, detail::workspace2< WORK, RWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -107,12 +106,14 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpev( jobz, uplo(), n, begin_value(ap), begin_value(w),
- begin_value(z), stride_major(z),
+ return detail::hpev( jobz, uplo(), size_column(ap), begin_value(ap),
+ begin_value(w), begin_value(z), stride_major(z),
begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
}
@@ -125,12 +126,14 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( jobz, n, ap, w, z, workspace( tmp_work, tmp_rwork ) );
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork ) );
}
//
@@ -141,10 +144,10 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- return invoke( jobz, n, ap, w, z, minimal_workspace() );
+ return invoke( jobz, ap, w, z, minimal_workspace() );
}
//
@@ -183,10 +186,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -197,10 +200,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -212,10 +215,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -226,10 +229,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -241,10 +244,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -255,10 +258,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -270,10 +273,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -284,10 +287,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -299,10 +302,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -313,10 +316,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -328,10 +331,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -342,10 +345,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -357,10 +360,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -371,10 +374,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -386,11 +389,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -401,10 +403,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return hpev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpevd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -100,9 +100,8 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename WORK, typename RWORK, typename IWORK >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, detail::workspace3< WORK,
- RWORK, IWORK > work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, detail::workspace3< WORK, RWORK, IWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -112,15 +111,15 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, n ));
+ min_size_iwork( jobz, size_column(ap) ));
BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- n ));
+ size_column(ap) ));
BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- n ));
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpevd( jobz, uplo(), n, begin_value(ap),
+ return detail::hpevd( jobz, uplo(), size_column(ap), begin_value(ap),
begin_value(w), begin_value(z), stride_major(z),
begin_value(work.select(value_type())),
size(work.select(value_type())),
@@ -138,16 +137,16 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
bindings::detail::array< value_type > tmp_work( min_size_work( jobz,
- n ) );
+ size_column(ap) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- n ) );
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, n ) );
- return invoke( jobz, n, ap, w, z, workspace( tmp_work, tmp_rwork,
+ min_size_iwork( jobz, size_column(ap) ) );
+ return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -159,22 +158,22 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hpevd( jobz, uplo(), n, begin_value(ap), begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
- &opt_size_rwork, -1, &opt_size_iwork, -1 );
+ detail::hpevd( jobz, uplo(), size_column(ap), begin_value(ap),
+ begin_value(w), begin_value(z), stride_major(z),
+ &opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< real_type > tmp_rwork(
traits::detail::to_int( opt_size_rwork ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
opt_size_iwork );
- return invoke( jobz, n, ap, w, z, workspace( tmp_work, tmp_rwork,
+ return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork,
tmp_iwork ) );
}
@@ -242,10 +241,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -256,10 +255,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -271,10 +270,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -285,10 +284,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -300,10 +299,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -314,10 +313,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -329,10 +328,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -343,10 +342,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -358,10 +357,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -372,10 +371,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -387,10 +386,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -401,10 +400,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -416,10 +415,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -430,10 +429,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -445,11 +444,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -460,10 +458,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t hpevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t hpevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return hpevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgv.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -98,9 +98,8 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename WORK, typename RWORK >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, detail::workspace2< WORK,
- RWORK > work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, detail::workspace2< WORK, RWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -115,13 +114,16 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpgv( itype, jobz, uplo(), n, begin_value(ap),
- begin_value(bp), begin_value(w), begin_value(z),
- stride_major(z), begin_value(work.select(value_type())),
+ return detail::hpgv( itype, jobz, uplo(), size_column(ap),
+ begin_value(ap), begin_value(bp), begin_value(w),
+ begin_value(z), stride_major(z),
+ begin_value(work.select(value_type())),
begin_value(work.select(real_type())) );
}
@@ -135,12 +137,14 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( itype, jobz, n, ap, bp, w, z, workspace( tmp_work,
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_rwork ) );
}
@@ -154,10 +158,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- return invoke( itype, jobz, n, ap, bp, w, z, minimal_workspace() );
+ return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() );
}
//
@@ -198,10 +202,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
+ Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -215,10 +219,9 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -232,10 +235,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -249,10 +252,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -266,10 +269,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -283,10 +286,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -300,10 +303,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -317,10 +320,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -334,10 +337,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -351,10 +354,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -368,10 +371,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -385,10 +388,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -402,10 +405,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -419,10 +422,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -436,10 +439,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -453,10 +456,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -470,10 +473,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -487,10 +490,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -504,10 +507,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -521,10 +524,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -538,10 +541,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -555,10 +558,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -572,10 +575,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -589,10 +592,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -606,10 +609,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -623,10 +626,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -640,10 +643,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -657,10 +660,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -674,11 +677,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -692,10 +694,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -709,11 +711,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -727,10 +728,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z ) {
return hpgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpgvd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -103,9 +103,8 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename WORK, typename RWORK, typename IWORK >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, detail::workspace3< WORK,
- RWORK, IWORK > work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, detail::workspace3< WORK, RWORK, IWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -120,17 +119,18 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, n ));
+ min_size_iwork( jobz, size_column(ap) ));
BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( jobz,
- n ));
+ size_column(ap) ));
BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( jobz,
- n ));
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::hpgvd( itype, jobz, uplo(), n, begin_value(ap),
- begin_value(bp), begin_value(w), begin_value(z),
- stride_major(z), begin_value(work.select(value_type())),
+ return detail::hpgvd( itype, jobz, uplo(), size_column(ap),
+ begin_value(ap), begin_value(bp), begin_value(w),
+ begin_value(z), stride_major(z),
+ begin_value(work.select(value_type())),
size(work.select(value_type())),
begin_value(work.select(real_type())),
size(work.select(real_type())),
@@ -148,16 +148,16 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
bindings::detail::array< value_type > tmp_work( min_size_work( jobz,
- n ) );
+ size_column(ap) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz,
- n ) );
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, n ) );
- return invoke( itype, jobz, n, ap, bp, w, z, workspace( tmp_work,
+ min_size_iwork( jobz, size_column(ap) ) );
+ return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_rwork, tmp_iwork ) );
}
@@ -171,23 +171,23 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
value_type opt_size_work;
real_type opt_size_rwork;
fortran_int_t opt_size_iwork;
- detail::hpgvd( itype, jobz, uplo(), n, begin_value(ap),
- begin_value(bp), begin_value(w), begin_value(z),
- stride_major(z), &opt_size_work, -1, &opt_size_rwork, -1,
- &opt_size_iwork, -1 );
+ detail::hpgvd( itype, jobz, uplo(), size_column(ap),
+ begin_value(ap), begin_value(bp), begin_value(w),
+ begin_value(z), stride_major(z), &opt_size_work, -1,
+ &opt_size_rwork, -1, &opt_size_iwork, -1 );
bindings::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< real_type > tmp_rwork(
traits::detail::to_int( opt_size_rwork ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
opt_size_iwork );
- return invoke( itype, jobz, n, ap, bp, w, z, workspace( tmp_work,
+ return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_rwork, tmp_iwork ) );
}
@@ -257,10 +257,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
+ Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -274,10 +274,9 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -291,10 +290,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -308,10 +307,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -325,10 +324,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -342,10 +341,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -359,10 +358,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -376,10 +375,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -393,10 +392,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -410,10 +409,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -427,10 +426,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -444,10 +443,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -461,10 +460,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -478,10 +477,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -495,10 +494,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -512,10 +511,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -529,10 +528,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -546,10 +545,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -563,10 +562,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -580,10 +579,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -597,10 +596,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -614,10 +613,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -631,10 +630,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -648,10 +647,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -665,10 +664,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -682,10 +681,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -699,10 +698,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -716,10 +715,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -733,11 +732,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -751,10 +749,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -768,11 +766,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -786,10 +783,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t hpgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z ) {
return hpgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/hpsvx.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -103,10 +103,10 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename WORK, typename RWORK >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, detail::workspace2< WORK, RWORK > work ) {
+ static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ detail::workspace2< WORK, RWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< VectorFERR >::type >::type,
@@ -130,16 +130,20 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorFERR >::value) );
BOOST_STATIC_ASSERT( (is_mutable< VectorBERR >::value) );
BOOST_ASSERT( fact == 'F' || fact == 'N' );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(berr) >= size_column(b) );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork( n ));
- BOOST_ASSERT( size(work.select(value_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_rwork(
+ size_column(ap) ));
+ BOOST_ASSERT( size(work.select(value_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_column(b) >= 0 );
BOOST_ASSERT( size_minor(b) == 1 || stride_minor(b) == 1 );
BOOST_ASSERT( size_minor(x) == 1 || stride_minor(x) == 1 );
- BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,n) );
- BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,n) );
- return detail::hpsvx( fact, uplo(), n, size_column(b),
+ BOOST_ASSERT( stride_major(b) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ BOOST_ASSERT( stride_major(x) >= std::max< std::ptrdiff_t >(1,
+ size_column(ap)) );
+ return detail::hpsvx( fact, uplo(), size_column(ap), size_column(b),
begin_value(ap), begin_value(afp), begin_value(ipiv),
begin_value(b), stride_major(b), begin_value(x),
stride_major(x), rcond, begin_value(ferr), begin_value(berr),
@@ -157,14 +161,16 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- bindings::detail::array< value_type > tmp_work( min_size_work( n ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n ) );
- return invoke( fact, n, ap, afp, ipiv, b, x, rcond, ferr, berr,
+ bindings::detail::array< value_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
+ size_column(ap) ) );
+ return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
@@ -178,12 +184,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
- static std::ptrdiff_t invoke( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr,
- VectorBERR& berr, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- return invoke( fact, n, ap, afp, ipiv, b, x, rcond, ferr, berr,
+ return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr,
minimal_workspace() );
}
@@ -226,13 +232,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -247,13 +253,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -268,13 +273,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -289,13 +294,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -310,13 +314,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -331,13 +335,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -352,13 +355,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -373,13 +376,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -394,13 +396,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -415,13 +417,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -436,13 +437,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -457,13 +458,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -478,13 +478,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -499,13 +499,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -520,13 +519,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr,
+ Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -541,13 +540,12 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
- VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -562,13 +560,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -583,13 +581,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -604,13 +602,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -625,13 +623,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -646,13 +644,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -667,13 +665,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -688,13 +686,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -709,13 +707,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -730,13 +728,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -751,13 +749,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -772,13 +770,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -793,13 +791,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -814,13 +812,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -835,13 +833,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -856,13 +854,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -877,13 +875,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -898,13 +896,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -919,13 +917,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -940,13 +938,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -961,13 +959,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -982,13 +980,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1003,13 +1001,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1024,13 +1022,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1045,13 +1043,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1066,13 +1064,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1087,13 +1085,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1108,13 +1106,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1129,13 +1127,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1150,13 +1148,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1171,13 +1169,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1192,13 +1190,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1213,13 +1211,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond, VectorFERR& ferr,
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, VectorFERR& ferr,
const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1234,13 +1232,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1255,13 +1253,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1276,13 +1274,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1297,13 +1295,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1318,13 +1316,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1339,13 +1337,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1360,13 +1358,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1381,13 +1379,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1402,13 +1400,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1423,13 +1421,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, const MatrixX& x,
+ typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1444,13 +1442,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1465,13 +1463,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1486,13 +1484,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1507,13 +1505,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
//
@@ -1528,13 +1526,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR, typename Workspace >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr, Workspace work ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr, Workspace work ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, work );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, work );
}
//
@@ -1549,13 +1547,13 @@
template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV,
typename MatrixB, typename MatrixX, typename VectorFERR,
typename VectorBERR >
-inline std::ptrdiff_t hpsvx( const char fact, const fortran_int_t n,
- const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv,
- const MatrixB& b, const MatrixX& x, typename remove_imaginary<
- typename value< MatrixAP >::type >::type& rcond,
- const VectorFERR& ferr, const VectorBERR& berr ) {
+inline std::ptrdiff_t hpsvx( const char fact, const MatrixAP& ap,
+ const MatrixAFP& afp, const VectorIPIV& ipiv, const MatrixB& b,
+ const MatrixX& x, typename remove_imaginary< typename value<
+ MatrixAP >::type >::type& rcond, const VectorFERR& ferr,
+ const VectorBERR& berr ) {
return hpsvx_impl< typename value< MatrixAP >::type >::invoke( fact,
- n, ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
+ ap, afp, ipiv, b, x, rcond, ferr, berr, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spev.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -94,9 +94,8 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename WORK >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, detail::workspace1<
- WORK > work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, detail::workspace1< WORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -110,11 +109,12 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spev( jobz, uplo(), n, begin_value(ap), begin_value(w),
- begin_value(z), stride_major(z),
+ return detail::spev( jobz, uplo(), size_column(ap), begin_value(ap),
+ begin_value(w), begin_value(z), stride_major(z),
begin_value(work.select(real_type())) );
}
@@ -126,11 +126,12 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( jobz, n, ap, w, z, workspace( tmp_work ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( jobz, ap, w, z, workspace( tmp_work ) );
}
//
@@ -141,10 +142,10 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- return invoke( jobz, n, ap, w, z, minimal_workspace() );
+ return invoke( jobz, ap, w, z, minimal_workspace() );
}
//
@@ -175,10 +176,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -189,10 +190,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -204,10 +205,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -218,10 +219,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -233,10 +234,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -247,10 +248,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -262,10 +263,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -276,10 +277,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -291,10 +292,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -305,10 +306,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -320,10 +321,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -334,10 +335,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -349,10 +350,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -363,10 +364,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -378,11 +379,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -393,10 +393,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spev( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spev( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return spev_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spevd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -98,9 +98,8 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, detail::workspace2< WORK,
- IWORK > work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, detail::workspace2< WORK, IWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -114,13 +113,13 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, n ));
+ min_size_iwork( jobz, size_column(ap) ));
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- n ));
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spevd( jobz, uplo(), n, begin_value(ap),
+ return detail::spevd( jobz, uplo(), size_column(ap), begin_value(ap),
begin_value(w), begin_value(z), stride_major(z),
begin_value(work.select(real_type())),
size(work.select(real_type())),
@@ -136,14 +135,14 @@
// * Enables the unblocked algorithm (BLAS level 2)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work( jobz,
- n ) );
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, n ) );
- return invoke( jobz, n, ap, w, z, workspace( tmp_work, tmp_iwork ) );
+ min_size_iwork( jobz, size_column(ap) ) );
+ return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) );
}
//
@@ -154,19 +153,19 @@
// * Enables the blocked algorithm (BLAS level 3)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
- static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::spevd( jobz, uplo(), n, begin_value(ap), begin_value(w),
- begin_value(z), stride_major(z), &opt_size_work, -1,
- &opt_size_iwork, -1 );
+ detail::spevd( jobz, uplo(), size_column(ap), begin_value(ap),
+ begin_value(w), begin_value(z), stride_major(z),
+ &opt_size_work, -1, &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
opt_size_iwork );
- return invoke( jobz, n, ap, w, z, workspace( tmp_work, tmp_iwork ) );
+ return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) );
}
//
@@ -217,10 +216,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -231,10 +230,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap, VectorW& w,
+ MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -246,10 +245,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -260,10 +259,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -275,10 +274,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -289,10 +288,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -304,10 +303,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -318,10 +317,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -333,10 +332,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -347,10 +346,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap, VectorW& w,
+ const MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -362,10 +361,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -376,10 +375,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ VectorW& w, const MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -391,10 +390,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z, Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -405,10 +404,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
//
@@ -420,11 +419,10 @@
//
template< typename MatrixAP, typename VectorW, typename MatrixZ,
typename Workspace >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, work );
+ ap, w, z, work );
}
//
@@ -435,10 +433,10 @@
// * Default workspace-type (optimal)
//
template< typename MatrixAP, typename VectorW, typename MatrixZ >
-inline std::ptrdiff_t spevd( const char jobz, const fortran_int_t n,
- const MatrixAP& ap, const VectorW& w, const MatrixZ& z ) {
+inline std::ptrdiff_t spevd( const char jobz, const MatrixAP& ap,
+ const VectorW& w, const MatrixZ& z ) {
return spevd_impl< typename value< MatrixAP >::type >::invoke( jobz,
- n, ap, w, z, optimal_workspace() );
+ ap, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgv.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -96,9 +96,8 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename WORK >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, detail::workspace1<
- WORK > work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, detail::workspace1< WORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -117,12 +116,14 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
- BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( n ));
+ BOOST_ASSERT( size(work.select(real_type())) >= min_size_work(
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spgv( itype, jobz, uplo(), n, begin_value(ap),
- begin_value(bp), begin_value(w), begin_value(z),
- stride_major(z), begin_value(work.select(real_type())) );
+ return detail::spgv( itype, jobz, uplo(), size_column(ap),
+ begin_value(ap), begin_value(bp), begin_value(w),
+ begin_value(z), stride_major(z),
+ begin_value(work.select(real_type())) );
}
//
@@ -135,11 +136,12 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- bindings::detail::array< real_type > tmp_work( min_size_work( n ) );
- return invoke( itype, jobz, n, ap, bp, w, z, workspace( tmp_work ) );
+ bindings::detail::array< real_type > tmp_work( min_size_work(
+ size_column(ap) ) );
+ return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work ) );
}
//
@@ -152,10 +154,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
- return invoke( itype, jobz, n, ap, bp, w, z, minimal_workspace() );
+ return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() );
}
//
@@ -188,10 +190,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
+ Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -205,10 +207,9 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -222,10 +223,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -239,10 +240,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -256,10 +257,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -273,10 +274,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -290,10 +291,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -307,10 +308,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -324,10 +325,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -341,10 +342,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -358,10 +359,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -375,10 +376,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -392,10 +393,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -409,10 +410,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -426,10 +427,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -443,10 +444,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -460,10 +461,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -477,10 +478,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -494,10 +495,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -511,10 +512,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -528,10 +529,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -545,10 +546,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -562,10 +563,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -579,10 +580,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -596,10 +597,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -613,10 +614,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -630,10 +631,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -647,10 +648,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -664,11 +665,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -682,10 +682,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -699,11 +699,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -717,10 +716,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgv( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z ) {
return spgv_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
} // namespace lapack
Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/spgvd.hpp 2010-01-13 09:02:11 EST (Wed, 13 Jan 2010)
@@ -99,9 +99,8 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename WORK, typename IWORK >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, detail::workspace2< WORK,
- IWORK > work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, detail::workspace2< WORK, IWORK > work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename value< MatrixAP >::type >::type,
@@ -120,15 +119,16 @@
BOOST_STATIC_ASSERT( (is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (is_mutable< MatrixZ >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
- BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( size(work.select(fortran_int_t())) >=
- min_size_iwork( jobz, n ));
+ min_size_iwork( jobz, size_column(ap) ));
BOOST_ASSERT( size(work.select(real_type())) >= min_size_work( jobz,
- n ));
+ size_column(ap) ));
+ BOOST_ASSERT( size_column(ap) >= 0 );
BOOST_ASSERT( size_minor(z) == 1 || stride_minor(z) == 1 );
- return detail::spgvd( itype, jobz, uplo(), n, begin_value(ap),
- begin_value(bp), begin_value(w), begin_value(z),
- stride_major(z), begin_value(work.select(real_type())),
+ return detail::spgvd( itype, jobz, uplo(), size_column(ap),
+ begin_value(ap), begin_value(bp), begin_value(w),
+ begin_value(z), stride_major(z),
+ begin_value(work.select(real_type())),
size(work.select(real_type())),
begin_value(work.select(fortran_int_t())),
size(work.select(fortran_int_t())) );
@@ -144,14 +144,14 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, minimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, minimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
bindings::detail::array< real_type > tmp_work( min_size_work( jobz,
- n ) );
+ size_column(ap) ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( jobz, n ) );
- return invoke( itype, jobz, n, ap, bp, w, z, workspace( tmp_work,
+ min_size_iwork( jobz, size_column(ap) ) );
+ return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_iwork ) );
}
@@ -165,19 +165,20 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
static std::ptrdiff_t invoke( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, optimal_workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, optimal_workspace work ) {
typedef typename result_of::data_side< MatrixAP >::type uplo;
real_type opt_size_work;
fortran_int_t opt_size_iwork;
- detail::spgvd( itype, jobz, uplo(), n, begin_value(ap),
- begin_value(bp), begin_value(w), begin_value(z),
- stride_major(z), &opt_size_work, -1, &opt_size_iwork, -1 );
+ detail::spgvd( itype, jobz, uplo(), size_column(ap),
+ begin_value(ap), begin_value(bp), begin_value(w),
+ begin_value(z), stride_major(z), &opt_size_work, -1,
+ &opt_size_iwork, -1 );
bindings::detail::array< real_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
bindings::detail::array< fortran_int_t > tmp_iwork(
opt_size_iwork );
- return invoke( itype, jobz, n, ap, bp, w, z, workspace( tmp_work,
+ return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work,
tmp_iwork ) );
}
@@ -231,10 +232,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z,
+ Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -248,10 +249,9 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -265,10 +265,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -282,10 +282,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -299,10 +299,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -316,10 +316,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -333,10 +333,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -350,10 +350,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -367,10 +367,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -384,10 +384,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -401,10 +401,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -418,10 +418,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -435,10 +435,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -452,10 +452,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -469,10 +469,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -486,10 +486,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -503,10 +503,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -520,10 +520,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -537,10 +537,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -554,10 +554,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -571,10 +571,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -588,10 +588,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -605,10 +605,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -622,10 +622,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp, VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -639,10 +639,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -656,10 +656,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -673,10 +673,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z, Workspace work ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -690,10 +690,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -707,11 +707,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -725,10 +724,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, MatrixAP& ap, const MatrixBP& bp, const VectorW& w,
+ const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
//
@@ -742,11 +741,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ, typename Workspace >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z,
- Workspace work ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z, Workspace work ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, work );
+ jobz, ap, bp, w, z, work );
}
//
@@ -760,10 +758,10 @@
template< typename MatrixAP, typename MatrixBP, typename VectorW,
typename MatrixZ >
inline std::ptrdiff_t spgvd( const fortran_int_t itype,
- const char jobz, const fortran_int_t n, const MatrixAP& ap,
- const MatrixBP& bp, const VectorW& w, const MatrixZ& z ) {
+ const char jobz, const MatrixAP& ap, const MatrixBP& bp,
+ const VectorW& w, const MatrixZ& z ) {
return spgvd_impl< typename value< MatrixAP >::type >::invoke( itype,
- jobz, n, ap, bp, w, z, optimal_workspace() );
+ jobz, ap, bp, w, z, optimal_workspace() );
}
} // namespace lapack
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