Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r63171 - in sandbox/numeric_bindings/boost/numeric/bindings/lapack: . auxiliary computational detail driver
From: thomas.klimpel_at_[hidden]
Date: 2010-06-20 16:53:51

Author: klimpel
Date: 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
New Revision: 63171
URL: http://svn.boost.org/trac/boost/changeset/63171

Log:
improved classification of the auxiliary routines of lapack
Added:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/labrd.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lacgv.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lacon.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/laebz.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/lalsd.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/larz.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/latrd.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/latrs.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary/latrz.hpp
      - copied unchanged from r63122, /sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp
Removed:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp
Text files modified:
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/auxiliary.hpp | 10 +
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational.hpp | 7
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack.h | 302 ++++++++++++++++++++--------------------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/detail/lapack_names.h | 112 +++++++-------
   sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver.hpp | 3
   5 files changed, 217 insertions(+), 217 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-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
@@ -35,5 +35,15 @@
#include <boost/numeric/bindings/lapack/auxiliary/lantb.hpp>
#include <boost/numeric/bindings/lapack/auxiliary/lantp.hpp>
#include <boost/numeric/bindings/lapack/auxiliary/lantr.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/labrd.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lacgv.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lacon.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/laebz.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/lalsd.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/largv.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/larz.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/latrd.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/latrs.hpp>
+#include <boost/numeric/bindings/lapack/auxiliary/latrz.hpp>

#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-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
@@ -26,8 +26,6 @@
#include <boost/numeric/bindings/lapack/computational/geqp3.hpp>
#include <boost/numeric/bindings/lapack/computational/geqrf.hpp>
#include <boost/numeric/bindings/lapack/computational/gerqf.hpp>
-#include <boost/numeric/bindings/lapack/computational/larz.hpp>
-#include <boost/numeric/bindings/lapack/computational/latrz.hpp>
#include <boost/numeric/bindings/lapack/computational/orglq.hpp>
#include <boost/numeric/bindings/lapack/computational/orgql.hpp>
#include <boost/numeric/bindings/lapack/computational/orgqr.hpp>
@@ -51,7 +49,6 @@
#include <boost/numeric/bindings/lapack/computational/bdsqr.hpp>
#include <boost/numeric/bindings/lapack/computational/gbbrd.hpp>
#include <boost/numeric/bindings/lapack/computational/gebrd.hpp>
-#include <boost/numeric/bindings/lapack/computational/labrd.hpp>
#include <boost/numeric/bindings/lapack/computational/orgbr.hpp>
#include <boost/numeric/bindings/lapack/computational/ormbr.hpp>
#include <boost/numeric/bindings/lapack/computational/ungbr.hpp>
@@ -93,8 +90,6 @@
#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>
#include <boost/numeric/bindings/lapack/computational/pbcon.hpp>
#include <boost/numeric/bindings/lapack/computational/pbequ.hpp>
#include <boost/numeric/bindings/lapack/computational/pbrfs.hpp>
@@ -141,8 +136,6 @@
#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>
#include <boost/numeric/bindings/lapack/computational/opmtr.hpp>
#include <boost/numeric/bindings/lapack/computational/orgtr.hpp>

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/labrd.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,411 +0,0 @@
-//
-// 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_LABRD_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LABRD_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/is_column_major.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_type.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 labrd 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 labrd( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t nb, float* a, const fortran_int_t lda, float* d,
- float* e, float* tauq, float* taup, float* x, const fortran_int_t ldx,
- float* y, const fortran_int_t ldy ) {
- fortran_int_t info(0);
- LAPACK_SLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t nb, double* a, const fortran_int_t lda, double* d,
- double* e, double* tauq, double* taup, double* x,
- const fortran_int_t ldx, double* y, const fortran_int_t ldy ) {
- fortran_int_t info(0);
- LAPACK_DLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<float> value-type.
-//
-inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t nb, std::complex<float>* a,
- const fortran_int_t lda, float* d, float* e,
- std::complex<float>* tauq, std::complex<float>* taup,
- std::complex<float>* x, const fortran_int_t ldx,
- std::complex<float>* y, const fortran_int_t ldy ) {
- fortran_int_t info(0);
- LAPACK_CLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t nb, std::complex<double>* a,
- const fortran_int_t lda, double* d, double* e,
- std::complex<double>* tauq, std::complex<double>* taup,
- std::complex<double>* x, const fortran_int_t ldx,
- std::complex<double>* y, const fortran_int_t ldy ) {
- fortran_int_t info(0);
- LAPACK_ZLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to labrd.
-//
-template< typename Value, typename Enable = void >
-struct labrd_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct labrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
- static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixY >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorD >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAUQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAUP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixY >::value) );
- BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size(e) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size(taup) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size(tauq) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::size_minor(x) == 1 ||
- bindings::stride_minor(x) == 1 );
- BOOST_ASSERT( bindings::size_minor(y) == 1 ||
- bindings::stride_minor(y) == 1 );
- BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(a)) );
- BOOST_ASSERT( bindings::stride_major(x) >= bindings::size_row(a) );
- BOOST_ASSERT( bindings::stride_major(y) >= bindings::size_column(a) );
- return detail::labrd( bindings::size_row(a), bindings::size_column(a),
- bindings::size_column(a), bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(tauq),
- bindings::begin_value(taup), bindings::begin_value(x),
- bindings::stride_major(x), bindings::begin_value(y),
- bindings::stride_major(y) );
- }
-
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct labrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
- static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixY >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAUQ >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAUP >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixY >::value) );
- BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size(e) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size(taup) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size(tauq) >= bindings::size_column(a) );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::size_minor(x) == 1 ||
- bindings::stride_minor(x) == 1 );
- BOOST_ASSERT( bindings::size_minor(y) == 1 ||
- bindings::stride_minor(y) == 1 );
- BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(a)) );
- BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(a)) );
- BOOST_ASSERT( bindings::stride_major(y) >= std::max< std::ptrdiff_t >(1,
- bindings::size_column(a)) );
- return detail::labrd( bindings::size_row(a), bindings::size_column(a),
- bindings::size_column(a), bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(tauq),
- bindings::begin_value(taup), bindings::begin_value(x),
- bindings::stride_major(x), bindings::begin_value(y),
- bindings::stride_major(y) );
- }
-
-};
-
-
-//
-// 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 labrd_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * MatrixA&
-// * MatrixX&
-// * MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * const MatrixA&
-// * MatrixX&
-// * MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( const MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * MatrixA&
-// * const MatrixX&
-// * MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, const MatrixX& x, MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * const MatrixA&
-// * const MatrixX&
-// * MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( const MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, const MatrixX& x, MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * MatrixA&
-// * MatrixX&
-// * const MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, const MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * const MatrixA&
-// * MatrixX&
-// * const MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( const MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, const MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * MatrixA&
-// * const MatrixX&
-// * const MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, const MatrixX& x,
- const MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-//
-// Overloaded function for labrd. Its overload differs for
-// * const MatrixA&
-// * const MatrixX&
-// * const MatrixY&
-//
-template< typename MatrixA, typename VectorD, typename VectorE,
- typename VectorTAUQ, typename VectorTAUP, typename MatrixX,
- typename MatrixY >
-inline std::ptrdiff_t labrd( const MatrixA& a, VectorD& d, VectorE& e,
- VectorTAUQ& tauq, VectorTAUP& taup, const MatrixX& x,
- const MatrixY& y ) {
- return labrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/lacon.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,296 +0,0 @@
-//
-// 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_LACON_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LACON_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.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_type.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 lacon 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 lacon( const fortran_int_t n, float* v, float* x,
- fortran_int_t* isgn, float& est, fortran_int_t& kase ) {
- fortran_int_t info(0);
- LAPACK_SLACON( &n, v, x, isgn, &est, &kase );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-inline std::ptrdiff_t lacon( const fortran_int_t n, double* v, double* x,
- fortran_int_t* isgn, double& est, fortran_int_t& kase ) {
- fortran_int_t info(0);
- LAPACK_DLACON( &n, v, x, isgn, &est, &kase );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<float> value-type.
-//
-inline std::ptrdiff_t lacon( const fortran_int_t n, std::complex<float>* v,
- std::complex<float>* x, float& est, fortran_int_t& kase ) {
- fortran_int_t info(0);
- LAPACK_CLACON( &n, v, x, &est, &kase );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-inline std::ptrdiff_t lacon( const fortran_int_t n, std::complex<double>* v,
- std::complex<double>* x, double& est, fortran_int_t& kase ) {
- fortran_int_t info(0);
- LAPACK_ZLACON( &n, v, x, &est, &kase );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to lacon.
-//
-template< typename Value, typename Enable = void >
-struct lacon_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct lacon_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 VectorX, typename V, typename ISGN >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- real_type& est, fortran_int_t& kase, detail::workspace2< V,
- ISGN > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
- BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
- min_size_isgn( n ));
- BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_v( n ));
- BOOST_ASSERT( n >= 1 );
- return detail::lacon( n,
- bindings::begin_value(work.select(real_type())),
- bindings::begin_value(x),
- bindings::begin_value(work.select(fortran_int_t())), est,
- kase );
- }
-
- //
- // 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 VectorX >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- real_type& est, fortran_int_t& kase, minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_v( min_size_v( n ) );
- bindings::detail::array<
- fortran_int_t > tmp_isgn( min_size_isgn( n ) );
- return invoke( n, x, est, kase, workspace( tmp_v, tmp_isgn ) );
- }
-
- //
- // 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 VectorX >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- real_type& est, fortran_int_t& kase, optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( n, x, est, kase, minimal_workspace() );
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array v.
- //
- static std::ptrdiff_t min_size_v( const std::ptrdiff_t n ) {
- return n;
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array isgn.
- //
- static std::ptrdiff_t min_size_isgn( const std::ptrdiff_t n ) {
- return n;
- }
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct lacon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 VectorX, typename V >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- real_type& est, fortran_int_t& kase, detail::workspace1<
- V > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
- BOOST_ASSERT( bindings::size(work.select(value_type())) >=
- min_size_v( n ));
- BOOST_ASSERT( n >= 1 );
- return detail::lacon( n,
- bindings::begin_value(work.select(value_type())),
- bindings::begin_value(x), est, kase );
- }
-
- //
- // 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 VectorX >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- real_type& est, fortran_int_t& kase, minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< value_type > tmp_v( min_size_v( n ) );
- return invoke( n, x, est, kase, workspace( tmp_v ) );
- }
-
- //
- // 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 VectorX >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- real_type& est, fortran_int_t& kase, optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( n, x, est, kase, minimal_workspace() );
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array v.
- //
- static std::ptrdiff_t min_size_v( 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 lacon_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for lacon. Its overload differs for
-// * User-defined workspace
-//
-template< typename VectorX, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-lacon( const fortran_int_t n, VectorX& x, typename remove_imaginary<
- typename bindings::value_type< VectorX >::type >::type& est,
- fortran_int_t& kase, Workspace work ) {
- return lacon_impl< typename bindings::value_type<
- VectorX >::type >::invoke( n, x, est, kase, work );
-}
-
-//
-// Overloaded function for lacon. Its overload differs for
-// * Default workspace-type (optimal)
-//
-template< typename VectorX >
-inline typename boost::disable_if< detail::is_workspace< VectorX >,
- std::ptrdiff_t >::type
-lacon( const fortran_int_t n, VectorX& x, typename remove_imaginary<
- typename bindings::value_type< VectorX >::type >::type& est,
- fortran_int_t& kase ) {
- return lacon_impl< typename bindings::value_type<
- VectorX >::type >::invoke( n, x, est, kase, optimal_workspace() );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/laebz.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,450 +0,0 @@
-//
-// 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_LAEBZ_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LAEBZ_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/detail/array.hpp>
-#include <boost/numeric/bindings/is_column_major.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_type.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-//
-// The LAPACK-backend for laebz 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 laebz( const fortran_int_t ijob,
- const fortran_int_t nitmax, const fortran_int_t n,
- const fortran_int_t mmax, const fortran_int_t minp,
- const fortran_int_t nbmin, const float abstol, const float reltol,
- const float pivmin, const float* d, const float* e, const float* e2,
- fortran_int_t* nval, float* ab, float* c, fortran_int_t& mout,
- fortran_int_t* nab, float* work, fortran_int_t* iwork ) {
- fortran_int_t info(0);
- LAPACK_SLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol, &reltol,
- &pivmin, d, e, e2, nval, ab, c, &mout, nab, work, iwork, &info );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-inline std::ptrdiff_t laebz( const fortran_int_t ijob,
- const fortran_int_t nitmax, const fortran_int_t n,
- const fortran_int_t mmax, const fortran_int_t minp,
- const fortran_int_t nbmin, const double abstol, const double reltol,
- const double pivmin, const double* d, const double* e,
- const double* e2, fortran_int_t* nval, double* ab, double* c,
- fortran_int_t& mout, fortran_int_t* nab, double* work,
- fortran_int_t* iwork ) {
- fortran_int_t info(0);
- LAPACK_DLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol, &reltol,
- &pivmin, d, e, e2, nval, ab, c, &mout, nab, work, iwork, &info );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to laebz.
-//
-template< typename Value >
-struct laebz_impl {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB, typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const fortran_int_t ijob,
- const fortran_int_t nitmax, const fortran_int_t n,
- const fortran_int_t minp, const fortran_int_t nbmin,
- const real_type abstol, const real_type reltol,
- const real_type pivmin, const VectorD& d, const VectorE& e,
- const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, MatrixNAB& nab, detail::workspace2< WORK,
- IWORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE2 >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixAB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorNVAL >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixNAB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorNVAL >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixNAB >::value) );
- BOOST_ASSERT( bindings::size(d) >= n );
- BOOST_ASSERT( bindings::size(e) >= n );
- BOOST_ASSERT( bindings::size(e2) >= n );
- BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
- min_size_iwork( bindings::stride_major(ab) ));
- BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( bindings::stride_major(ab) ));
- BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
- bindings::stride_minor(ab) == 1 );
- return detail::laebz( ijob, nitmax, n, bindings::stride_major(ab),
- minp, nbmin, abstol, reltol, pivmin, bindings::begin_value(d),
- bindings::begin_value(e), bindings::begin_value(e2),
- bindings::begin_value(nval), bindings::begin_value(ab),
- bindings::begin_value(c), mout, bindings::begin_value(nab),
- bindings::begin_value(work.select(real_type())),
- bindings::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 VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB >
- static std::ptrdiff_t invoke( const fortran_int_t ijob,
- const fortran_int_t nitmax, const fortran_int_t n,
- const fortran_int_t minp, const fortran_int_t nbmin,
- const real_type abstol, const real_type reltol,
- const real_type pivmin, const VectorD& d, const VectorE& e,
- const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, MatrixNAB& nab, minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work(
- bindings::stride_major(ab) ) );
- bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( bindings::stride_major(ab) ) );
- return invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin,
- d, e, e2, nval, ab, c, mout, nab, 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 VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB >
- static std::ptrdiff_t invoke( const fortran_int_t ijob,
- const fortran_int_t nitmax, const fortran_int_t n,
- const fortran_int_t minp, const fortran_int_t nbmin,
- const real_type abstol, const real_type reltol,
- const real_type pivmin, const VectorD& d, const VectorE& e,
- const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, MatrixNAB& nab, optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin,
- d, e, e2, nval, ab, c, mout, nab, 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 mmax ) {
- return mmax;
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array iwork.
- //
- static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t mmax ) {
- return mmax;
- }
-};
-
-
-//
-// 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 laebz_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * MatrixAB&
-// * MatrixNAB&
-// * User-defined workspace
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, MatrixAB& ab, VectorC& c, fortran_int_t& mout,
- MatrixNAB& nab, Workspace work ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * MatrixAB&
-// * MatrixNAB&
-// * Default workspace-type (optimal)
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB >
-inline typename boost::disable_if< detail::is_workspace< MatrixNAB >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, MatrixAB& ab, VectorC& c, fortran_int_t& mout,
- MatrixNAB& nab ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab,
- optimal_workspace() );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * const MatrixAB&
-// * MatrixNAB&
-// * User-defined workspace
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, const MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, MatrixNAB& nab, Workspace work ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * const MatrixAB&
-// * MatrixNAB&
-// * Default workspace-type (optimal)
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB >
-inline typename boost::disable_if< detail::is_workspace< MatrixNAB >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, const MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, MatrixNAB& nab ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab,
- optimal_workspace() );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * MatrixAB&
-// * const MatrixNAB&
-// * User-defined workspace
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, MatrixAB& ab, VectorC& c, fortran_int_t& mout,
- const MatrixNAB& nab, Workspace work ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * MatrixAB&
-// * const MatrixNAB&
-// * Default workspace-type (optimal)
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB >
-inline typename boost::disable_if< detail::is_workspace< MatrixNAB >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, MatrixAB& ab, VectorC& c, fortran_int_t& mout,
- const MatrixNAB& nab ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab,
- optimal_workspace() );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * const MatrixAB&
-// * const MatrixNAB&
-// * User-defined workspace
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, const MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, const MatrixNAB& nab, Workspace work ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work );
-}
-
-//
-// Overloaded function for laebz. Its overload differs for
-// * const MatrixAB&
-// * const MatrixNAB&
-// * Default workspace-type (optimal)
-//
-template< typename VectorD, typename VectorE, typename VectorE2,
- typename VectorNVAL, typename MatrixAB, typename VectorC,
- typename MatrixNAB >
-inline typename boost::disable_if< detail::is_workspace< MatrixNAB >,
- std::ptrdiff_t >::type
-laebz( const fortran_int_t ijob, const fortran_int_t nitmax,
- const fortran_int_t n, const fortran_int_t minp,
- const fortran_int_t nbmin, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type abstol,
- const typename remove_imaginary< typename bindings::value_type<
- VectorD >::type >::type reltol, const typename remove_imaginary<
- typename bindings::value_type< VectorD >::type >::type pivmin,
- const VectorD& d, const VectorE& e, const VectorE2& e2,
- VectorNVAL& nval, const MatrixAB& ab, VectorC& c,
- fortran_int_t& mout, const MatrixNAB& nab ) {
- return laebz_impl< typename bindings::value_type<
- VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol,
- reltol, pivmin, d, e, e2, nval, ab, c, mout, nab,
- optimal_workspace() );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/larz.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,440 +0,0 @@
-//
-// 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_LARZ_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LARZ_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/detail/array.hpp>
-#include <boost/numeric/bindings/is_column_major.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_type.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 larz 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 Side >
-inline std::ptrdiff_t larz( const Side side, const fortran_int_t m,
- const fortran_int_t n, const fortran_int_t l, const float* v,
- const fortran_int_t incv, const float tau, float* c,
- const fortran_int_t ldc, float* work ) {
- fortran_int_t info(0);
- LAPACK_SLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau,
- c, &ldc, work );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-template< typename Side >
-inline std::ptrdiff_t larz( const Side side, const fortran_int_t m,
- const fortran_int_t n, const fortran_int_t l, const double* v,
- const fortran_int_t incv, const double tau, double* c,
- const fortran_int_t ldc, double* work ) {
- fortran_int_t info(0);
- LAPACK_DLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau,
- c, &ldc, work );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<float> value-type.
-//
-template< typename Side >
-inline std::ptrdiff_t larz( const Side side, const fortran_int_t m,
- const fortran_int_t n, const fortran_int_t l,
- const std::complex<float>* v, const fortran_int_t incv,
- const std::complex<float> tau, std::complex<float>* c,
- const fortran_int_t ldc, std::complex<float>* work ) {
- fortran_int_t info(0);
- LAPACK_CLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau,
- c, &ldc, work );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-template< typename Side >
-inline std::ptrdiff_t larz( const Side side, const fortran_int_t m,
- const fortran_int_t n, const fortran_int_t l,
- const std::complex<double>* v, const fortran_int_t incv,
- const std::complex<double> tau, std::complex<double>* c,
- const fortran_int_t ldc, std::complex<double>* work ) {
- fortran_int_t info(0);
- LAPACK_ZLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau,
- c, &ldc, work );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to larz.
-//
-template< typename Value, typename Enable = void >
-struct larz_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct larz_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 Side, typename VectorViewV, typename MatrixC,
- typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t l,
- const VectorViewV& v, const real_type tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorViewV >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( side, bindings::size_row(c),
- bindings::size_column(c) ));
- BOOST_ASSERT( bindings::size_minor(c) == 1 ||
- bindings::stride_minor(c) == 1 );
- BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(c)) );
- return detail::larz( side, bindings::size_row(c),
- bindings::size_column(c), l, bindings::begin_value(v),
- bindings::stride(v), tau, bindings::begin_value(c),
- bindings::stride_major(c),
- bindings::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 Side, typename VectorViewV, typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t l,
- const VectorViewV& v, const real_type tau, MatrixC& c,
- minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work( side,
- bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, l, v, tau, c, 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 Side, typename VectorViewV, typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t l,
- const VectorViewV& v, const real_type tau, MatrixC& c,
- optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( side, l, v, tau, c, minimal_workspace() );
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array work.
- //
- template< typename Side >
- static std::ptrdiff_t min_size_work( const Side side,
- const std::ptrdiff_t m, const std::ptrdiff_t n ) {
- if ( side == 'L' )
- return n;
- else
- return m;
- }
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct larz_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 Side, typename VectorViewV, typename MatrixC,
- typename WORK >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t l,
- const VectorViewV& v, const value_type tau, MatrixC& c,
- detail::workspace1< WORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorViewV >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) );
- BOOST_ASSERT( bindings::size(work.select(value_type())) >=
- min_size_work( side, bindings::size_row(c),
- bindings::size_column(c) ));
- BOOST_ASSERT( bindings::size_minor(c) == 1 ||
- bindings::stride_minor(c) == 1 );
- BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(c)) );
- return detail::larz( side, bindings::size_row(c),
- bindings::size_column(c), l, bindings::begin_value(v),
- bindings::stride(v), tau, bindings::begin_value(c),
- bindings::stride_major(c),
- bindings::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 Side, typename VectorViewV, typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t l,
- const VectorViewV& v, const value_type tau, MatrixC& c,
- minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< value_type > tmp_work( min_size_work( side,
- bindings::size_row(c), bindings::size_column(c) ) );
- return invoke( side, l, v, tau, c, 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 Side, typename VectorViewV, typename MatrixC >
- static std::ptrdiff_t invoke( const Side side, const fortran_int_t l,
- const VectorViewV& v, const value_type tau, MatrixC& c,
- optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( side, l, v, tau, c, minimal_workspace() );
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array work.
- //
- template< typename Side >
- static std::ptrdiff_t min_size_work( const Side side,
- const std::ptrdiff_t m, const std::ptrdiff_t n ) {
- if ( side == 'L' )
- return n;
- else
- return m;
- }
-};
-
-
-//
-// 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 larz_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for larz. Its overload differs for
-// * MatrixC&
-// * User-defined workspace
-//
-template< typename Side, typename VectorViewV, typename MatrixC,
- typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename remove_imaginary< typename bindings::value_type<
- VectorViewV >::type >::type tau, MatrixC& c, Workspace work ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c, work );
-}
-
-//
-// Overloaded function for larz. Its overload differs for
-// * MatrixC&
-// * Default workspace-type (optimal)
-//
-template< typename Side, typename VectorViewV, typename MatrixC >
-inline typename boost::disable_if< detail::is_workspace< MatrixC >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename remove_imaginary< typename bindings::value_type<
- VectorViewV >::type >::type tau, MatrixC& c ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c,
- optimal_workspace() );
-}
-
-//
-// Overloaded function for larz. Its overload differs for
-// * const MatrixC&
-// * User-defined workspace
-//
-template< typename Side, typename VectorViewV, typename MatrixC,
- typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename remove_imaginary< typename bindings::value_type<
- VectorViewV >::type >::type tau, const MatrixC& c, Workspace work ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c, work );
-}
-
-//
-// Overloaded function for larz. Its overload differs for
-// * const MatrixC&
-// * Default workspace-type (optimal)
-//
-template< typename Side, typename VectorViewV, typename MatrixC >
-inline typename boost::disable_if< detail::is_workspace< MatrixC >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename remove_imaginary< typename bindings::value_type<
- VectorViewV >::type >::type tau, const MatrixC& c ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c,
- optimal_workspace() );
-}
-//
-// Overloaded function for larz. Its overload differs for
-// * MatrixC&
-// * User-defined workspace
-//
-template< typename Side, typename VectorViewV, typename MatrixC,
- typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename bindings::value_type< VectorViewV >::type tau,
- MatrixC& c, Workspace work ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c, work );
-}
-
-//
-// Overloaded function for larz. Its overload differs for
-// * MatrixC&
-// * Default workspace-type (optimal)
-//
-template< typename Side, typename VectorViewV, typename MatrixC >
-inline typename boost::disable_if< detail::is_workspace< MatrixC >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename bindings::value_type< VectorViewV >::type tau,
- MatrixC& c ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c,
- optimal_workspace() );
-}
-
-//
-// Overloaded function for larz. Its overload differs for
-// * const MatrixC&
-// * User-defined workspace
-//
-template< typename Side, typename VectorViewV, typename MatrixC,
- typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename bindings::value_type< VectorViewV >::type tau,
- const MatrixC& c, Workspace work ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c, work );
-}
-
-//
-// Overloaded function for larz. Its overload differs for
-// * const MatrixC&
-// * Default workspace-type (optimal)
-//
-template< typename Side, typename VectorViewV, typename MatrixC >
-inline typename boost::disable_if< detail::is_workspace< MatrixC >,
- std::ptrdiff_t >::type
-larz( const Side side, const fortran_int_t l, const VectorViewV& v,
- const typename bindings::value_type< VectorViewV >::type tau,
- const MatrixC& c ) {
- return larz_impl< typename bindings::value_type<
- VectorViewV >::type >::invoke( side, l, v, tau, c,
- optimal_workspace() );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrd.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,291 +0,0 @@
-//
-// 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_LATRD_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LATRD_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/is_column_major.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/uplo_tag.hpp>
-#include <boost/numeric/bindings/value_type.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 latrd 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 latrd( const UpLo uplo, const fortran_int_t n,
- const fortran_int_t nb, float* a, const fortran_int_t lda, float* e,
- float* tau, float* w, const fortran_int_t ldw ) {
- fortran_int_t info(0);
- LAPACK_SLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w,
- &ldw );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-template< typename UpLo >
-inline std::ptrdiff_t latrd( const UpLo uplo, const fortran_int_t n,
- const fortran_int_t nb, double* a, const fortran_int_t lda, double* e,
- double* tau, double* w, const fortran_int_t ldw ) {
- fortran_int_t info(0);
- LAPACK_DLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w,
- &ldw );
- 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 latrd( const UpLo uplo, const fortran_int_t n,
- const fortran_int_t nb, std::complex<float>* a,
- const fortran_int_t lda, float* e, std::complex<float>* tau,
- std::complex<float>* w, const fortran_int_t ldw ) {
- fortran_int_t info(0);
- LAPACK_CLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w,
- &ldw );
- 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 latrd( const UpLo uplo, const fortran_int_t n,
- const fortran_int_t nb, std::complex<double>* a,
- const fortran_int_t lda, double* e, std::complex<double>* tau,
- std::complex<double>* w, const fortran_int_t ldw ) {
- fortran_int_t info(0);
- LAPACK_ZLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w,
- &ldw );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to latrd.
-//
-template< typename Value, typename Enable = void >
-struct latrd_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct latrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename MatrixA, typename VectorE, typename VectorTAU,
- typename MatrixW >
- static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a,
- VectorE& e, VectorTAU& tau, MatrixW& w ) {
- namespace bindings = ::boost::numeric::bindings;
- typedef typename result_of::uplo_tag< MatrixA >::type uplo;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixW >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixW >::value) );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::size_minor(w) == 1 ||
- bindings::stride_minor(w) == 1 );
- BOOST_ASSERT( bindings::stride_major(a) >= (ERROR) );
- BOOST_ASSERT( bindings::stride_major(w) >= std::max< std::ptrdiff_t >(1,
- bindings::size_column(a)) );
- return detail::latrd( uplo(), bindings::size_column(a), nb,
- bindings::begin_value(a), bindings::stride_major(a),
- bindings::begin_value(e), bindings::begin_value(tau),
- bindings::begin_value(w), bindings::stride_major(w) );
- }
-
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct latrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename MatrixA, typename VectorE, typename VectorTAU,
- typename MatrixW >
- static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a,
- VectorE& e, VectorTAU& tau, MatrixW& w ) {
- namespace bindings = ::boost::numeric::bindings;
- typedef typename result_of::uplo_tag< MatrixA >::type uplo;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixW >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixW >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixW >::value) );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::size_minor(w) == 1 ||
- bindings::stride_minor(w) == 1 );
- BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- bindings::size_column(a)) );
- BOOST_ASSERT( bindings::stride_major(w) >= std::max< std::ptrdiff_t >(1,
- bindings::size_column(a)) );
- return detail::latrd( uplo(), bindings::size_column(a), nb,
- bindings::begin_value(a), bindings::stride_major(a),
- bindings::begin_value(e), bindings::begin_value(tau),
- bindings::begin_value(w), bindings::stride_major(w) );
- }
-
-};
-
-
-//
-// 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 latrd_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for latrd. Its overload differs for
-// * MatrixA&
-// * MatrixW&
-//
-template< typename MatrixA, typename VectorE, typename VectorTAU,
- typename MatrixW >
-inline std::ptrdiff_t latrd( const fortran_int_t nb, MatrixA& a,
- VectorE& e, VectorTAU& tau, MatrixW& w ) {
- return latrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( nb, a, e, tau, w );
-}
-
-//
-// Overloaded function for latrd. Its overload differs for
-// * const MatrixA&
-// * MatrixW&
-//
-template< typename MatrixA, typename VectorE, typename VectorTAU,
- typename MatrixW >
-inline std::ptrdiff_t latrd( const fortran_int_t nb, const MatrixA& a,
- VectorE& e, VectorTAU& tau, MatrixW& w ) {
- return latrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( nb, a, e, tau, w );
-}
-
-//
-// Overloaded function for latrd. Its overload differs for
-// * MatrixA&
-// * const MatrixW&
-//
-template< typename MatrixA, typename VectorE, typename VectorTAU,
- typename MatrixW >
-inline std::ptrdiff_t latrd( const fortran_int_t nb, MatrixA& a,
- VectorE& e, VectorTAU& tau, const MatrixW& w ) {
- return latrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( nb, a, e, tau, w );
-}
-
-//
-// Overloaded function for latrd. Its overload differs for
-// * const MatrixA&
-// * const MatrixW&
-//
-template< typename MatrixA, typename VectorE, typename VectorTAU,
- typename MatrixW >
-inline std::ptrdiff_t latrd( const fortran_int_t nb, const MatrixA& a,
- VectorE& e, VectorTAU& tau, const MatrixW& w ) {
- return latrd_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( nb, a, e, tau, w );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrs.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,244 +0,0 @@
-//
-// 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_LATRS_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LATRS_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/blas/detail/default_order.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/remove_imaginary.hpp>
-#include <boost/numeric/bindings/size.hpp>
-#include <boost/numeric/bindings/stride.hpp>
-#include <boost/numeric/bindings/trans_tag.hpp>
-#include <boost/numeric/bindings/uplo_tag.hpp>
-#include <boost/numeric/bindings/value_type.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 latrs 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 Trans, typename Diag >
-inline std::ptrdiff_t latrs( const char uplo, const Trans trans,
- const Diag diag, const char normin, const fortran_int_t n,
- const float* a, const fortran_int_t lda, float* x, float& scale,
- float* cnorm ) {
- fortran_int_t info(0);
- LAPACK_SLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t latrs( const char uplo, const Trans trans,
- const Diag diag, const char normin, const fortran_int_t n,
- const double* a, const fortran_int_t lda, double* x, double& scale,
- double* cnorm ) {
- fortran_int_t info(0);
- LAPACK_DLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<float> value-type.
-//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t latrs( const char uplo, const Trans trans,
- const Diag diag, const char normin, const fortran_int_t n,
- const std::complex<float>* a, const fortran_int_t lda,
- std::complex<float>* x, float& scale, float* cnorm ) {
- fortran_int_t info(0);
- LAPACK_CLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-template< typename Trans, typename Diag >
-inline std::ptrdiff_t latrs( const char uplo, const Trans trans,
- const Diag diag, const char normin, const fortran_int_t n,
- const std::complex<double>* a, const fortran_int_t lda,
- std::complex<double>* x, double& scale, double* cnorm ) {
- fortran_int_t info(0);
- LAPACK_ZLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option<
- Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to latrs.
-//
-template< typename Value, typename Enable = void >
-struct latrs_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct latrs_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename MatrixA, typename VectorX, typename VectorCNORM >
- static std::ptrdiff_t invoke( const char uplo, const char normin,
- const MatrixA& a, VectorX& x, real_type& scale,
- VectorCNORM& cnorm ) {
- namespace bindings = ::boost::numeric::bindings;
- typedef typename detail::default_order< MatrixA >::type order;
- 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<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorCNORM >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorCNORM >::value) );
- BOOST_ASSERT( bindings::size(x) >= bindings::size_column_op(a,
- trans()) );
- BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::stride_major(a) >= ?MAX );
- BOOST_ASSERT( normin == 'Y' || normin == 'N' );
- return detail::latrs( uplo, trans(), diag(), normin,
- bindings::size_column_op(a, trans()),
- bindings::begin_value(a), bindings::stride_major(a),
- bindings::begin_value(x), scale,
- bindings::begin_value(cnorm) );
- }
-
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct latrs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename MatrixA, typename VectorX, typename VectorCNORM >
- static std::ptrdiff_t invoke( const char uplo, const char normin,
- const MatrixA& a, VectorX& x, real_type& scale,
- VectorCNORM& cnorm ) {
- namespace bindings = ::boost::numeric::bindings;
- typedef typename detail::default_order< MatrixA >::type order;
- 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<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorX >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorCNORM >::value) );
- BOOST_ASSERT( bindings::size(x) >= bindings::size_column_op(a,
- trans()) );
- BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::stride_major(a) >= ?MAX );
- BOOST_ASSERT( normin == 'Y' || normin == 'N' );
- return detail::latrs( uplo, trans(), diag(), normin,
- bindings::size_column_op(a, trans()),
- bindings::begin_value(a), bindings::stride_major(a),
- bindings::begin_value(x), scale,
- bindings::begin_value(cnorm) );
- }
-
-};
-
-
-//
-// 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 latrs_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for latrs. Its overload differs for
-//
-template< typename MatrixA, typename VectorX, typename VectorCNORM >
-inline std::ptrdiff_t latrs( const char uplo, const char normin,
- const MatrixA& a, VectorX& x, typename remove_imaginary<
- typename bindings::value_type< MatrixA >::type >::type& scale,
- VectorCNORM& cnorm ) {
- return latrs_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( uplo, normin, a, x, scale, cnorm );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/computational/latrz.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,341 +0,0 @@
-//
-// 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_LATRZ_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_LATRZ_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/detail/array.hpp>
-#include <boost/numeric/bindings/is_column_major.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_type.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 latrz 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 latrz( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t l, float* a, const fortran_int_t lda, float* tau,
- float* work ) {
- fortran_int_t info(0);
- LAPACK_SLATRZ( &m, &n, &l, a, &lda, tau, work );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t l, double* a, const fortran_int_t lda,
- double* tau, double* work ) {
- fortran_int_t info(0);
- LAPACK_DLATRZ( &m, &n, &l, a, &lda, tau, work );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<float> value-type.
-//
-inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t l, std::complex<float>* a,
- const fortran_int_t lda, std::complex<float>* tau,
- std::complex<float>* work ) {
- fortran_int_t info(0);
- LAPACK_CLATRZ( &m, &n, &l, a, &lda, tau, work );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n,
- const fortran_int_t l, std::complex<double>* a,
- const fortran_int_t lda, std::complex<double>* tau,
- std::complex<double>* work ) {
- fortran_int_t info(0);
- LAPACK_ZLATRZ( &m, &n, &l, a, &lda, tau, work );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to latrz.
-//
-template< typename Value, typename Enable = void >
-struct latrz_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct latrz_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 MatrixA, typename VectorTAU, typename WORK >
- static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
- detail::workspace1< WORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) );
- BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( bindings::size_row(a) ));
- BOOST_ASSERT( bindings::size_column(a) >= 0 );
- BOOST_ASSERT( bindings::size_column(a) >= 0 );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::size_row(a) >= 0 );
- BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(a)) );
- return detail::latrz( bindings::size_row(a), bindings::size_column(a),
- bindings::size_column(a), bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::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 MatrixA, typename VectorTAU >
- static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
- minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< real_type > tmp_work( min_size_work(
- bindings::size_row(a) ) );
- return invoke( a, tau, 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 MatrixA, typename VectorTAU >
- static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
- optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( a, tau, 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 m ) {
- return m;
- }
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct latrz_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 MatrixA, typename VectorTAU, typename WORK >
- static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
- detail::workspace1< WORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< MatrixA >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorTAU >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) );
- BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) );
- BOOST_ASSERT( bindings::size(work.select(value_type())) >=
- min_size_work( bindings::size_row(a) ));
- BOOST_ASSERT( bindings::size_column(a) >= 0 );
- BOOST_ASSERT( bindings::size_column(a) >= 0 );
- BOOST_ASSERT( bindings::size_minor(a) == 1 ||
- bindings::stride_minor(a) == 1 );
- BOOST_ASSERT( bindings::size_row(a) >= 0 );
- BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
- bindings::size_row(a)) );
- return detail::latrz( bindings::size_row(a), bindings::size_column(a),
- bindings::size_column(a), bindings::begin_value(a),
- bindings::stride_major(a), bindings::begin_value(tau),
- bindings::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 MatrixA, typename VectorTAU >
- static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
- minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- bindings::detail::array< value_type > tmp_work( min_size_work(
- bindings::size_row(a) ) );
- return invoke( a, tau, 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 MatrixA, typename VectorTAU >
- static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau,
- optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( a, tau, 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 m ) {
- return m;
- }
-};
-
-
-//
-// 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 latrz_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for latrz. Its overload differs for
-// * MatrixA&
-// * User-defined workspace
-//
-template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-latrz( MatrixA& a, VectorTAU& tau, Workspace work ) {
- return latrz_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, tau, work );
-}
-
-//
-// Overloaded function for latrz. Its overload differs for
-// * MatrixA&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename VectorTAU >
-inline typename boost::disable_if< detail::is_workspace< VectorTAU >,
- std::ptrdiff_t >::type
-latrz( MatrixA& a, VectorTAU& tau ) {
- return latrz_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, tau, optimal_workspace() );
-}
-
-//
-// Overloaded function for latrz. Its overload differs for
-// * const MatrixA&
-// * User-defined workspace
-//
-template< typename MatrixA, typename VectorTAU, typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-latrz( const MatrixA& a, VectorTAU& tau, Workspace work ) {
- return latrz_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, tau, work );
-}
-
-//
-// Overloaded function for latrz. Its overload differs for
-// * const MatrixA&
-// * Default workspace-type (optimal)
-//
-template< typename MatrixA, typename VectorTAU >
-inline typename boost::disable_if< detail::is_workspace< VectorTAU >,
- std::ptrdiff_t >::type
-latrz( const MatrixA& a, VectorTAU& tau ) {
- return latrz_impl< typename bindings::value_type<
- MatrixA >::type >::invoke( a, tau, optimal_workspace() );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

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-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
@@ -189,38 +189,6 @@
         const fortran_int_t* lda, void* tau, void* work,
         const fortran_int_t* lwork, fortran_int_t* info );

-// Value-type variants of larz
-void LAPACK_SLARZ( const char* side, const fortran_int_t* m,
- const fortran_int_t* n, const fortran_int_t* l, const float* v,
- const fortran_int_t* incv, const float* tau, float* c,
- const fortran_int_t* ldc, float* work );
-void LAPACK_DLARZ( const char* side, const fortran_int_t* m,
- const fortran_int_t* n, const fortran_int_t* l, const double* v,
- const fortran_int_t* incv, const double* tau, double* c,
- const fortran_int_t* ldc, double* work );
-void LAPACK_CLARZ( const char* side, const fortran_int_t* m,
- const fortran_int_t* n, const fortran_int_t* l, const void* v,
- const fortran_int_t* incv, const void* tau, void* c,
- const fortran_int_t* ldc, void* work );
-void LAPACK_ZLARZ( const char* side, const fortran_int_t* m,
- const fortran_int_t* n, const fortran_int_t* l, const void* v,
- const fortran_int_t* incv, const void* tau, void* c,
- const fortran_int_t* ldc, void* work );
-
-// Value-type variants of latrz
-void LAPACK_SLATRZ( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* l, float* a, const fortran_int_t* lda,
- float* tau, float* work );
-void LAPACK_DLATRZ( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* l, double* a, const fortran_int_t* lda,
- double* tau, double* work );
-void LAPACK_CLATRZ( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* l, void* a, const fortran_int_t* lda, void* tau,
- void* work );
-void LAPACK_ZLATRZ( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* l, void* a, const fortran_int_t* lda, void* tau,
- void* work );
-
// Value-type variants of orglq
void LAPACK_SORGLQ( const fortran_int_t* m, const fortran_int_t* n,
         const fortran_int_t* k, float* a, const fortran_int_t* lda,
@@ -520,24 +488,6 @@
         void* taup, void* work, const fortran_int_t* lwork,
         fortran_int_t* info );

-// Value-type variants of labrd
-void LAPACK_SLABRD( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* nb, float* a, const fortran_int_t* lda, float* d,
- float* e, float* tauq, float* taup, float* x,
- const fortran_int_t* ldx, float* y, const fortran_int_t* ldy );
-void LAPACK_DLABRD( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* nb, double* a, const fortran_int_t* lda,
- double* d, double* e, double* tauq, double* taup, double* x,
- const fortran_int_t* ldx, double* y, const fortran_int_t* ldy );
-void LAPACK_CLABRD( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* nb, void* a, const fortran_int_t* lda, float* d,
- float* e, void* tauq, void* taup, void* x, const fortran_int_t* ldx,
- void* y, const fortran_int_t* ldy );
-void LAPACK_ZLABRD( const fortran_int_t* m, const fortran_int_t* n,
- const fortran_int_t* nb, void* a, const fortran_int_t* lda, double* d,
- double* e, void* tauq, void* taup, void* x, const fortran_int_t* ldx,
- void* y, const fortran_int_t* ldy );
-
// Value-type variants of orgbr
void LAPACK_SORGBR( const char* vect, const fortran_int_t* m,
         const fortran_int_t* n, const fortran_int_t* k, float* a,
@@ -1169,34 +1119,6 @@
         const fortran_int_t* nrhs, const void* ap, const fortran_int_t* ipiv,
         void* b, const fortran_int_t* ldb, fortran_int_t* info );

-// Value-type variants of lacon
-void LAPACK_SLACON( const fortran_int_t* n, float* v, float* x,
- fortran_int_t* isgn, float* est, fortran_int_t* kase );
-void LAPACK_DLACON( const fortran_int_t* n, double* v, double* x,
- fortran_int_t* isgn, double* est, fortran_int_t* kase );
-void LAPACK_CLACON( const fortran_int_t* n, void* v, void* x, float* est,
- fortran_int_t* kase );
-void LAPACK_ZLACON( const fortran_int_t* n, void* v, void* x, double* est,
- fortran_int_t* kase );
-
-// Value-type variants of latrs
-void LAPACK_SLATRS( const char* uplo, const char* trans, const char* diag,
- const char* normin, const fortran_int_t* n, const float* a,
- const fortran_int_t* lda, float* x, float* scale, float* cnorm,
- fortran_int_t* info );
-void LAPACK_DLATRS( const char* uplo, const char* trans, const char* diag,
- const char* normin, const fortran_int_t* n, const double* a,
- const fortran_int_t* lda, double* x, double* scale, double* cnorm,
- fortran_int_t* info );
-void LAPACK_CLATRS( const char* uplo, const char* trans, const char* diag,
- const char* normin, const fortran_int_t* n, const void* a,
- const fortran_int_t* lda, void* x, float* scale, float* cnorm,
- fortran_int_t* info );
-void LAPACK_ZLATRS( const char* uplo, const char* trans, const char* diag,
- const char* normin, const fortran_int_t* n, const void* a,
- const fortran_int_t* lda, void* x, double* scale, double* cnorm,
- fortran_int_t* info );
-
// Value-type variants of pbcon
void LAPACK_SPBCON( const char* uplo, const fortran_int_t* n,
         const fortran_int_t* kd, const float* ab, const fortran_int_t* ldab,
@@ -1906,37 +1828,6 @@
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,
- const fortran_int_t* minp, const fortran_int_t* nbmin,
- const float* abstol, const float* reltol, const float* pivmin,
- const float* d, const float* e, const float* e2, fortran_int_t* nval,
- float* ab, float* c, fortran_int_t* mout, fortran_int_t* nab,
- float* work, fortran_int_t* iwork, fortran_int_t* info );
-void LAPACK_DLAEBZ( const fortran_int_t* ijob, const fortran_int_t* nitmax,
- const fortran_int_t* n, const fortran_int_t* mmax,
- const fortran_int_t* minp, const fortran_int_t* nbmin,
- const double* abstol, const double* reltol, const double* pivmin,
- const double* d, const double* e, const double* e2,
- fortran_int_t* nval, double* ab, double* c, fortran_int_t* mout,
- fortran_int_t* nab, double* work, fortran_int_t* iwork,
- fortran_int_t* info );
-
-// Value-type variants of latrd
-void LAPACK_SLATRD( const char* uplo, const fortran_int_t* n,
- const fortran_int_t* nb, float* a, const fortran_int_t* lda, float* e,
- float* tau, float* w, const fortran_int_t* ldw );
-void LAPACK_DLATRD( const char* uplo, const fortran_int_t* n,
- const fortran_int_t* nb, double* a, const fortran_int_t* lda,
- double* e, double* tau, double* w, const fortran_int_t* ldw );
-void LAPACK_CLATRD( const char* uplo, const fortran_int_t* n,
- const fortran_int_t* nb, void* a, const fortran_int_t* lda, float* e,
- void* tau, void* w, const fortran_int_t* ldw );
-void LAPACK_ZLATRD( const char* uplo, const fortran_int_t* n,
- const fortran_int_t* nb, void* a, const fortran_int_t* lda, double* e,
- void* tau, void* w, const fortran_int_t* ldw );
-
// Value-type variants of opgtr
void LAPACK_SOPGTR( const char* uplo, const fortran_int_t* n, const float* ap,
         const float* tau, float* q, const fortran_int_t* ldq, float* work,
@@ -2825,26 +2716,6 @@
         double* rwork, fortran_int_t* iwork, fortran_int_t* ifail,
         fortran_int_t* info );

-// Value-type variants of lacgv
-void LAPACK_CLACGV( const fortran_int_t* n, void* x,
- const fortran_int_t* incx );
-void LAPACK_ZLACGV( const fortran_int_t* n, void* x,
- const fortran_int_t* incx );
-
-// Value-type variants of largv
-void LAPACK_SLARGV( const fortran_int_t* n, float* x,
- const fortran_int_t* incx, float* y, const fortran_int_t* incy,
- float* c, const fortran_int_t* incc );
-void LAPACK_DLARGV( const fortran_int_t* n, double* x,
- const fortran_int_t* incx, double* y, const fortran_int_t* incy,
- double* c, const fortran_int_t* incc );
-void LAPACK_CLARGV( const fortran_int_t* n, void* x,
- const fortran_int_t* incx, void* y, const fortran_int_t* incy,
- float* c, const fortran_int_t* incc );
-void LAPACK_ZLARGV( const fortran_int_t* n, void* x,
- const fortran_int_t* incx, void* y, const fortran_int_t* incy,
- double* c, const fortran_int_t* incc );
-
// Value-type variants of sbgv
void LAPACK_SSBGV( const char* jobz, const char* uplo, const fortran_int_t* n,
         const fortran_int_t* ka, const fortran_int_t* kb, float* ab,
@@ -4021,28 +3892,6 @@
         fortran_int_t* rank, void* work, const fortran_int_t* lwork,
         double* rwork, fortran_int_t* info );

-// Value-type variants of lalsd
-void LAPACK_SLALSD( const char* uplo, const fortran_int_t* smlsiz,
- const fortran_int_t* n, const fortran_int_t* nrhs, float* d, float* e,
- float* b, const fortran_int_t* ldb, const float* rcond,
- fortran_int_t* rank, float* work, fortran_int_t* iwork,
- fortran_int_t* info );
-void LAPACK_DLALSD( const char* uplo, const fortran_int_t* smlsiz,
- const fortran_int_t* n, const fortran_int_t* nrhs, double* d,
- double* e, double* b, const fortran_int_t* ldb, const double* rcond,
- fortran_int_t* rank, double* work, fortran_int_t* iwork,
- fortran_int_t* info );
-void LAPACK_CLALSD( const char* uplo, const fortran_int_t* smlsiz,
- const fortran_int_t* n, const fortran_int_t* nrhs, float* d, float* e,
- void* b, const fortran_int_t* ldb, const float* rcond,
- fortran_int_t* rank, void* work, float* rwork, fortran_int_t* iwork,
- fortran_int_t* info );
-void LAPACK_ZLALSD( const char* uplo, const fortran_int_t* smlsiz,
- const fortran_int_t* n, const fortran_int_t* nrhs, double* d,
- double* e, void* b, const fortran_int_t* ldb, const double* rcond,
- fortran_int_t* rank, void* work, double* rwork, fortran_int_t* iwork,
- fortran_int_t* info );
-
//
// LAPACK auxiliary routines
//
@@ -4318,6 +4167,157 @@
         const fortran_int_t* m, const fortran_int_t* n, const void* a,
         const fortran_int_t* lda, double* work );

+// Value-type variants of labrd
+void LAPACK_SLABRD( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* nb, float* a, const fortran_int_t* lda, float* d,
+ float* e, float* tauq, float* taup, float* x,
+ const fortran_int_t* ldx, float* y, const fortran_int_t* ldy );
+void LAPACK_DLABRD( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* nb, double* a, const fortran_int_t* lda,
+ double* d, double* e, double* tauq, double* taup, double* x,
+ const fortran_int_t* ldx, double* y, const fortran_int_t* ldy );
+void LAPACK_CLABRD( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* nb, void* a, const fortran_int_t* lda, float* d,
+ float* e, void* tauq, void* taup, void* x, const fortran_int_t* ldx,
+ void* y, const fortran_int_t* ldy );
+void LAPACK_ZLABRD( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* nb, void* a, const fortran_int_t* lda, double* d,
+ double* e, void* tauq, void* taup, void* x, const fortran_int_t* ldx,
+ void* y, const fortran_int_t* ldy );
+
+// Value-type variants of lacgv
+void LAPACK_CLACGV( const fortran_int_t* n, void* x,
+ const fortran_int_t* incx );
+void LAPACK_ZLACGV( const fortran_int_t* n, void* x,
+ const fortran_int_t* incx );
+
+// Value-type variants of lacon
+void LAPACK_SLACON( const fortran_int_t* n, float* v, float* x,
+ fortran_int_t* isgn, float* est, fortran_int_t* kase );
+void LAPACK_DLACON( const fortran_int_t* n, double* v, double* x,
+ fortran_int_t* isgn, double* est, fortran_int_t* kase );
+void LAPACK_CLACON( const fortran_int_t* n, void* v, void* x, float* est,
+ fortran_int_t* kase );
+void LAPACK_ZLACON( const fortran_int_t* n, void* v, void* x, double* est,
+ fortran_int_t* kase );
+
+// 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,
+ const fortran_int_t* minp, const fortran_int_t* nbmin,
+ const float* abstol, const float* reltol, const float* pivmin,
+ const float* d, const float* e, const float* e2, fortran_int_t* nval,
+ float* ab, float* c, fortran_int_t* mout, fortran_int_t* nab,
+ float* work, fortran_int_t* iwork, fortran_int_t* info );
+void LAPACK_DLAEBZ( const fortran_int_t* ijob, const fortran_int_t* nitmax,
+ const fortran_int_t* n, const fortran_int_t* mmax,
+ const fortran_int_t* minp, const fortran_int_t* nbmin,
+ const double* abstol, const double* reltol, const double* pivmin,
+ const double* d, const double* e, const double* e2,
+ fortran_int_t* nval, double* ab, double* c, fortran_int_t* mout,
+ fortran_int_t* nab, double* work, fortran_int_t* iwork,
+ fortran_int_t* info );
+
+// Value-type variants of lalsd
+void LAPACK_SLALSD( const char* uplo, const fortran_int_t* smlsiz,
+ const fortran_int_t* n, const fortran_int_t* nrhs, float* d, float* e,
+ float* b, const fortran_int_t* ldb, const float* rcond,
+ fortran_int_t* rank, float* work, fortran_int_t* iwork,
+ fortran_int_t* info );
+void LAPACK_DLALSD( const char* uplo, const fortran_int_t* smlsiz,
+ const fortran_int_t* n, const fortran_int_t* nrhs, double* d,
+ double* e, double* b, const fortran_int_t* ldb, const double* rcond,
+ fortran_int_t* rank, double* work, fortran_int_t* iwork,
+ fortran_int_t* info );
+void LAPACK_CLALSD( const char* uplo, const fortran_int_t* smlsiz,
+ const fortran_int_t* n, const fortran_int_t* nrhs, float* d, float* e,
+ void* b, const fortran_int_t* ldb, const float* rcond,
+ fortran_int_t* rank, void* work, float* rwork, fortran_int_t* iwork,
+ fortran_int_t* info );
+void LAPACK_ZLALSD( const char* uplo, const fortran_int_t* smlsiz,
+ const fortran_int_t* n, const fortran_int_t* nrhs, double* d,
+ double* e, void* b, const fortran_int_t* ldb, const double* rcond,
+ fortran_int_t* rank, void* work, double* rwork, fortran_int_t* iwork,
+ fortran_int_t* info );
+
+// Value-type variants of largv
+void LAPACK_SLARGV( const fortran_int_t* n, float* x,
+ const fortran_int_t* incx, float* y, const fortran_int_t* incy,
+ float* c, const fortran_int_t* incc );
+void LAPACK_DLARGV( const fortran_int_t* n, double* x,
+ const fortran_int_t* incx, double* y, const fortran_int_t* incy,
+ double* c, const fortran_int_t* incc );
+void LAPACK_CLARGV( const fortran_int_t* n, void* x,
+ const fortran_int_t* incx, void* y, const fortran_int_t* incy,
+ float* c, const fortran_int_t* incc );
+void LAPACK_ZLARGV( const fortran_int_t* n, void* x,
+ const fortran_int_t* incx, void* y, const fortran_int_t* incy,
+ double* c, const fortran_int_t* incc );
+
+// Value-type variants of larz
+void LAPACK_SLARZ( const char* side, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* l, const float* v,
+ const fortran_int_t* incv, const float* tau, float* c,
+ const fortran_int_t* ldc, float* work );
+void LAPACK_DLARZ( const char* side, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* l, const double* v,
+ const fortran_int_t* incv, const double* tau, double* c,
+ const fortran_int_t* ldc, double* work );
+void LAPACK_CLARZ( const char* side, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* l, const void* v,
+ const fortran_int_t* incv, const void* tau, void* c,
+ const fortran_int_t* ldc, void* work );
+void LAPACK_ZLARZ( const char* side, const fortran_int_t* m,
+ const fortran_int_t* n, const fortran_int_t* l, const void* v,
+ const fortran_int_t* incv, const void* tau, void* c,
+ const fortran_int_t* ldc, void* work );
+
+// Value-type variants of latrd
+void LAPACK_SLATRD( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* nb, float* a, const fortran_int_t* lda, float* e,
+ float* tau, float* w, const fortran_int_t* ldw );
+void LAPACK_DLATRD( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* nb, double* a, const fortran_int_t* lda,
+ double* e, double* tau, double* w, const fortran_int_t* ldw );
+void LAPACK_CLATRD( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* nb, void* a, const fortran_int_t* lda, float* e,
+ void* tau, void* w, const fortran_int_t* ldw );
+void LAPACK_ZLATRD( const char* uplo, const fortran_int_t* n,
+ const fortran_int_t* nb, void* a, const fortran_int_t* lda, double* e,
+ void* tau, void* w, const fortran_int_t* ldw );
+
+// Value-type variants of latrs
+void LAPACK_SLATRS( const char* uplo, const char* trans, const char* diag,
+ const char* normin, const fortran_int_t* n, const float* a,
+ const fortran_int_t* lda, float* x, float* scale, float* cnorm,
+ fortran_int_t* info );
+void LAPACK_DLATRS( const char* uplo, const char* trans, const char* diag,
+ const char* normin, const fortran_int_t* n, const double* a,
+ const fortran_int_t* lda, double* x, double* scale, double* cnorm,
+ fortran_int_t* info );
+void LAPACK_CLATRS( const char* uplo, const char* trans, const char* diag,
+ const char* normin, const fortran_int_t* n, const void* a,
+ const fortran_int_t* lda, void* x, float* scale, float* cnorm,
+ fortran_int_t* info );
+void LAPACK_ZLATRS( const char* uplo, const char* trans, const char* diag,
+ const char* normin, const fortran_int_t* n, const void* a,
+ const fortran_int_t* lda, void* x, double* scale, double* cnorm,
+ fortran_int_t* info );
+
+// Value-type variants of latrz
+void LAPACK_SLATRZ( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* l, float* a, const fortran_int_t* lda,
+ float* tau, float* work );
+void LAPACK_DLATRZ( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* l, double* a, const fortran_int_t* lda,
+ double* tau, double* work );
+void LAPACK_CLATRZ( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* l, void* a, const fortran_int_t* lda, void* tau,
+ void* work );
+void LAPACK_ZLATRZ( const fortran_int_t* m, const fortran_int_t* n,
+ const fortran_int_t* l, void* a, const fortran_int_t* lda, void* tau,
+ void* work );
+
//
// LAPACK auxiliary routines
//

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-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
@@ -88,18 +88,6 @@
#define LAPACK_CGERQF FORTRAN_ID( cgerqf )
#define LAPACK_ZGERQF FORTRAN_ID( zgerqf )

-// Value-type variants of larz
-#define LAPACK_SLARZ FORTRAN_ID( slarz )
-#define LAPACK_DLARZ FORTRAN_ID( dlarz )
-#define LAPACK_CLARZ FORTRAN_ID( clarz )
-#define LAPACK_ZLARZ FORTRAN_ID( zlarz )
-
-// Value-type variants of latrz
-#define LAPACK_SLATRZ FORTRAN_ID( slatrz )
-#define LAPACK_DLATRZ FORTRAN_ID( dlatrz )
-#define LAPACK_CLATRZ FORTRAN_ID( clatrz )
-#define LAPACK_ZLATRZ FORTRAN_ID( zlatrz )
-
// Value-type variants of orglq
#define LAPACK_SORGLQ FORTRAN_ID( sorglq )
#define LAPACK_DORGLQ FORTRAN_ID( dorglq )
@@ -200,12 +188,6 @@
#define LAPACK_CGEBRD FORTRAN_ID( cgebrd )
#define LAPACK_ZGEBRD FORTRAN_ID( zgebrd )

-// Value-type variants of labrd
-#define LAPACK_SLABRD FORTRAN_ID( slabrd )
-#define LAPACK_DLABRD FORTRAN_ID( dlabrd )
-#define LAPACK_CLABRD FORTRAN_ID( clabrd )
-#define LAPACK_ZLABRD FORTRAN_ID( zlabrd )
-
// Value-type variants of orgbr
#define LAPACK_SORGBR FORTRAN_ID( sorgbr )
#define LAPACK_DORGBR FORTRAN_ID( dorgbr )
@@ -414,18 +396,6 @@
#define LAPACK_CHPTRS FORTRAN_ID( chptrs )
#define LAPACK_ZHPTRS FORTRAN_ID( zhptrs )

-// Value-type variants of lacon
-#define LAPACK_SLACON FORTRAN_ID( slacon )
-#define LAPACK_DLACON FORTRAN_ID( dlacon )
-#define LAPACK_CLACON FORTRAN_ID( clacon )
-#define LAPACK_ZLACON FORTRAN_ID( zlacon )
-
-// Value-type variants of latrs
-#define LAPACK_SLATRS FORTRAN_ID( slatrs )
-#define LAPACK_DLATRS FORTRAN_ID( dlatrs )
-#define LAPACK_CLATRS FORTRAN_ID( clatrs )
-#define LAPACK_ZLATRS FORTRAN_ID( zlatrs )
-
// Value-type variants of pbcon
#define LAPACK_SPBCON FORTRAN_ID( spbcon )
#define LAPACK_DPBCON FORTRAN_ID( dpbcon )
@@ -696,16 +666,6 @@
#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 )
-
-// Value-type variants of latrd
-#define LAPACK_SLATRD FORTRAN_ID( slatrd )
-#define LAPACK_DLATRD FORTRAN_ID( dlatrd )
-#define LAPACK_CLATRD FORTRAN_ID( clatrd )
-#define LAPACK_ZLATRD FORTRAN_ID( zlatrd )
-
// Value-type variants of opgtr
#define LAPACK_SOPGTR FORTRAN_ID( sopgtr )
#define LAPACK_DOPGTR FORTRAN_ID( dopgtr )
@@ -936,16 +896,6 @@
#define LAPACK_CHPGVX FORTRAN_ID( chpgvx )
#define LAPACK_ZHPGVX FORTRAN_ID( zhpgvx )

-// Value-type variants of lacgv
-#define LAPACK_CLACGV FORTRAN_ID( clacgv )
-#define LAPACK_ZLACGV FORTRAN_ID( zlacgv )
-
-// Value-type variants of largv
-#define LAPACK_SLARGV FORTRAN_ID( slargv )
-#define LAPACK_DLARGV FORTRAN_ID( dlargv )
-#define LAPACK_CLARGV FORTRAN_ID( clargv )
-#define LAPACK_ZLARGV FORTRAN_ID( zlargv )
-
// Value-type variants of sbgv
#define LAPACK_SSBGV FORTRAN_ID( ssbgv )
#define LAPACK_DSBGV FORTRAN_ID( dsbgv )
@@ -1286,12 +1236,6 @@
#define LAPACK_CGELSY FORTRAN_ID( cgelsy )
#define LAPACK_ZGELSY FORTRAN_ID( zgelsy )

-// Value-type variants of lalsd
-#define LAPACK_SLALSD FORTRAN_ID( slalsd )
-#define LAPACK_DLALSD FORTRAN_ID( dlalsd )
-#define LAPACK_CLALSD FORTRAN_ID( clalsd )
-#define LAPACK_ZLALSD FORTRAN_ID( zlalsd )
-
//
// LAPACK auxiliary routines
//
@@ -1412,6 +1356,62 @@
#define LAPACK_CLANTR FORTRAN_ID( clantr )
#define LAPACK_ZLANTR FORTRAN_ID( zlantr )

+// Value-type variants of labrd
+#define LAPACK_SLABRD FORTRAN_ID( slabrd )
+#define LAPACK_DLABRD FORTRAN_ID( dlabrd )
+#define LAPACK_CLABRD FORTRAN_ID( clabrd )
+#define LAPACK_ZLABRD FORTRAN_ID( zlabrd )
+
+// Value-type variants of lacgv
+#define LAPACK_CLACGV FORTRAN_ID( clacgv )
+#define LAPACK_ZLACGV FORTRAN_ID( zlacgv )
+
+// Value-type variants of lacon
+#define LAPACK_SLACON FORTRAN_ID( slacon )
+#define LAPACK_DLACON FORTRAN_ID( dlacon )
+#define LAPACK_CLACON FORTRAN_ID( clacon )
+#define LAPACK_ZLACON FORTRAN_ID( zlacon )
+
+// Value-type variants of laebz
+#define LAPACK_SLAEBZ FORTRAN_ID( slaebz )
+#define LAPACK_DLAEBZ FORTRAN_ID( dlaebz )
+
+// Value-type variants of lalsd
+#define LAPACK_SLALSD FORTRAN_ID( slalsd )
+#define LAPACK_DLALSD FORTRAN_ID( dlalsd )
+#define LAPACK_CLALSD FORTRAN_ID( clalsd )
+#define LAPACK_ZLALSD FORTRAN_ID( zlalsd )
+
+// Value-type variants of largv
+#define LAPACK_SLARGV FORTRAN_ID( slargv )
+#define LAPACK_DLARGV FORTRAN_ID( dlargv )
+#define LAPACK_CLARGV FORTRAN_ID( clargv )
+#define LAPACK_ZLARGV FORTRAN_ID( zlargv )
+
+// Value-type variants of larz
+#define LAPACK_SLARZ FORTRAN_ID( slarz )
+#define LAPACK_DLARZ FORTRAN_ID( dlarz )
+#define LAPACK_CLARZ FORTRAN_ID( clarz )
+#define LAPACK_ZLARZ FORTRAN_ID( zlarz )
+
+// Value-type variants of latrd
+#define LAPACK_SLATRD FORTRAN_ID( slatrd )
+#define LAPACK_DLATRD FORTRAN_ID( dlatrd )
+#define LAPACK_CLATRD FORTRAN_ID( clatrd )
+#define LAPACK_ZLATRD FORTRAN_ID( zlatrd )
+
+// Value-type variants of latrs
+#define LAPACK_SLATRS FORTRAN_ID( slatrs )
+#define LAPACK_DLATRS FORTRAN_ID( dlatrs )
+#define LAPACK_CLATRS FORTRAN_ID( clatrs )
+#define LAPACK_ZLATRS FORTRAN_ID( zlatrs )
+
+// Value-type variants of latrz
+#define LAPACK_SLATRZ FORTRAN_ID( slatrz )
+#define LAPACK_DLATRZ FORTRAN_ID( dlatrz )
+#define LAPACK_CLATRZ FORTRAN_ID( clatrz )
+#define LAPACK_ZLATRZ FORTRAN_ID( zlatrz )
+
//
// LAPACK auxiliary routines
//

Modified: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver.hpp (original)
+++ sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
@@ -29,8 +29,6 @@
#include <boost/numeric/bindings/lapack/driver/hpgv.hpp>
#include <boost/numeric/bindings/lapack/driver/hpgvd.hpp>
#include <boost/numeric/bindings/lapack/driver/hpgvx.hpp>
-#include <boost/numeric/bindings/lapack/driver/lacgv.hpp>
-#include <boost/numeric/bindings/lapack/driver/largv.hpp>
#include <boost/numeric/bindings/lapack/driver/sbgv.hpp>
#include <boost/numeric/bindings/lapack/driver/sbgvd.hpp>
#include <boost/numeric/bindings/lapack/driver/sbgvx.hpp>
@@ -101,6 +99,5 @@
#include <boost/numeric/bindings/lapack/driver/gelsd.hpp>
#include <boost/numeric/bindings/lapack/driver/gelss.hpp>
#include <boost/numeric/bindings/lapack/driver/gelsy.hpp>
-#include <boost/numeric/bindings/lapack/driver/lalsd.hpp>

#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lacgv.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,122 +0,0 @@
-//
-// 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_DRIVER_LACGV_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_LACGV_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.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_type.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-//
-// The LAPACK-backend for lacgv 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 lacgv( const fortran_int_t n, std::complex<float>* x,
- const fortran_int_t incx ) {
- fortran_int_t info(0);
- LAPACK_CLACGV( &n, x, &incx );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-inline std::ptrdiff_t lacgv( const fortran_int_t n, std::complex<double>* x,
- const fortran_int_t incx ) {
- fortran_int_t info(0);
- LAPACK_ZLACGV( &n, x, &incx );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to lacgv.
-//
-template< typename Value >
-struct lacgv_impl {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename VectorX >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x,
- const fortran_int_t incx ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) );
- BOOST_ASSERT( n >= 0 );
- return detail::lacgv( n, bindings::begin_value(x), incx );
- }
-
-};
-
-
-//
-// 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 lacgv_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for lacgv. Its overload differs for
-//
-template< typename VectorX >
-inline std::ptrdiff_t lacgv( const fortran_int_t n, VectorX& x,
- const fortran_int_t incx ) {
- return lacgv_impl< typename bindings::value_type<
- VectorX >::type >::invoke( n, x, incx );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/lalsd.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,465 +0,0 @@
-//
-// 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_DRIVER_LALSD_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_LALSD_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.hpp>
-#include <boost/numeric/bindings/detail/array.hpp>
-#include <boost/numeric/bindings/is_column_major.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/uplo_tag.hpp>
-#include <boost/numeric/bindings/value_type.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 lalsd 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 lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, const fortran_int_t nrhs, float* d, float* e,
- float* b, const fortran_int_t ldb, const float rcond,
- fortran_int_t& rank, float* work, fortran_int_t* iwork ) {
- fortran_int_t info(0);
- LAPACK_SLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank,
- work, iwork, &info );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-inline std::ptrdiff_t lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, const fortran_int_t nrhs, double* d, double* e,
- double* b, const fortran_int_t ldb, const double rcond,
- fortran_int_t& rank, double* work, fortran_int_t* iwork ) {
- fortran_int_t info(0);
- LAPACK_DLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank,
- 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 lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, const fortran_int_t nrhs, float* d, float* e,
- std::complex<float>* b, const fortran_int_t ldb, const float rcond,
- fortran_int_t& rank, std::complex<float>* work, float* rwork,
- fortran_int_t* iwork ) {
- fortran_int_t info(0);
- LAPACK_CLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank,
- work, rwork, iwork, &info );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-inline std::ptrdiff_t lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, const fortran_int_t nrhs, double* d, double* e,
- std::complex<double>* b, const fortran_int_t ldb, const double rcond,
- fortran_int_t& rank, std::complex<double>* work, double* rwork,
- fortran_int_t* iwork ) {
- fortran_int_t info(0);
- LAPACK_ZLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank,
- work, rwork, iwork, &info );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to lalsd.
-//
-template< typename Value, typename Enable = void >
-struct lalsd_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct lalsd_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 VectorD, typename VectorE, typename MatrixB,
- typename WORK, typename IWORK >
- static std::ptrdiff_t invoke( const char uplo,
- const fortran_int_t smlsiz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
- fortran_int_t& rank, detail::workspace2< WORK, IWORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- MatrixB >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
- std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
- static_cast<std::ptrdiff_t>(
- std::log(static_cast<real_type>(n)/static_cast<real_type>(smlsiz+
- 1)) /
- std::log(static_cast<real_type>(2.)) ) + 1 );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
- BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
- min_size_iwork( n, nlvl ));
- BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_work( n, smlsiz, nlvl, bindings::size_column(b) ));
- BOOST_ASSERT( bindings::size_column(b) >= 1 );
- BOOST_ASSERT( bindings::size_minor(b) == 1 ||
- bindings::stride_minor(b) == 1 );
- BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::lalsd( uplo, smlsiz, n, bindings::size_column(b),
- bindings::begin_value(d), bindings::begin_value(e),
- bindings::begin_value(b), bindings::stride_major(b), rcond,
- rank, bindings::begin_value(work.select(real_type())),
- bindings::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 VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo,
- const fortran_int_t smlsiz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
- fortran_int_t& rank, minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
- static_cast<std::ptrdiff_t>(
- std::log(static_cast<real_type>(n)/static_cast<real_type>(smlsiz+
- 1)) /
- std::log(static_cast<real_type>(2.)) ) + 1 );
- bindings::detail::array< real_type > tmp_work( min_size_work( n,
- smlsiz, nlvl, bindings::size_column(b) ) );
- bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n, nlvl ) );
- return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- 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 VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo,
- const fortran_int_t smlsiz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
- fortran_int_t& rank, optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- 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,
- const std::ptrdiff_t smlsiz, const std::ptrdiff_t nlvl,
- const std::ptrdiff_t nrhs ) {
- std::ptrdiff_t smlsiz_plus_one = smlsiz + 1;
- return 9*n + 2*n*smlsiz + 8*n*nlvl + n*nrhs +
- smlsiz_plus_one * smlsiz_plus_one;
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array iwork.
- //
- static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n,
- const std::ptrdiff_t nlvl ) {
- return 3*n*nlvl + 11*n;
- }
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct lalsd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // 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 VectorD, typename VectorE, typename MatrixB,
- typename WORK, typename RWORK, typename IWORK >
- static std::ptrdiff_t invoke( const char uplo,
- const fortran_int_t smlsiz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
- fortran_int_t& rank, detail::workspace3< WORK, RWORK,
- IWORK > work ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorD >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorE >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
- std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
- static_cast<std::ptrdiff_t>(
- std::log(static_cast<real_type>(std::min<
- std::ptrdiff_t >(traits::matrix_size2(b),n))/
- static_cast<real_type>(smlsiz+1)) /
- std::log(static_cast<real_type>(2.))) + 1 );
- BOOST_ASSERT( bindings::size(e) >= n-1 );
- BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
- min_size_iwork( n, nlvl ));
- BOOST_ASSERT( bindings::size(work.select(real_type())) >=
- min_size_rwork( n, smlsiz, nlvl, bindings::size_column(b) ));
- BOOST_ASSERT( bindings::size(work.select(value_type())) >=
- min_size_work( n, bindings::size_column(b) ));
- BOOST_ASSERT( bindings::size_column(b) >= 1 );
- BOOST_ASSERT( bindings::size_minor(b) == 1 ||
- bindings::stride_minor(b) == 1 );
- BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
- n) );
- BOOST_ASSERT( n >= 0 );
- return detail::lalsd( uplo, smlsiz, n, bindings::size_column(b),
- bindings::begin_value(d), bindings::begin_value(e),
- bindings::begin_value(b), bindings::stride_major(b), rcond,
- rank, bindings::begin_value(work.select(value_type())),
- bindings::begin_value(work.select(real_type())),
- bindings::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 VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo,
- const fortran_int_t smlsiz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
- fortran_int_t& rank, minimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0,
- static_cast<std::ptrdiff_t>(
- std::log(static_cast<real_type>(std::min<
- std::ptrdiff_t >(traits::matrix_size2(b),n))/
- static_cast<real_type>(smlsiz+1)) /
- std::log(static_cast<real_type>(2.))) + 1 );
- bindings::detail::array< value_type > tmp_work( min_size_work( n,
- bindings::size_column(b) ) );
- bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n,
- smlsiz, nlvl, bindings::size_column(b) ) );
- bindings::detail::array< fortran_int_t > tmp_iwork(
- min_size_iwork( n, nlvl ) );
- return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- workspace( tmp_work, tmp_rwork, 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 VectorD, typename VectorE, typename MatrixB >
- static std::ptrdiff_t invoke( const char uplo,
- const fortran_int_t smlsiz, const fortran_int_t n,
- VectorD& d, VectorE& e, MatrixB& b, const real_type rcond,
- fortran_int_t& rank, optimal_workspace ) {
- namespace bindings = ::boost::numeric::bindings;
- return invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- 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,
- const std::ptrdiff_t nrhs ) {
- return n*nrhs;
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array rwork.
- //
- static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n,
- const std::ptrdiff_t smlsiz, const std::ptrdiff_t nlvl,
- const std::ptrdiff_t nrhs ) {
- std::ptrdiff_t smlsiz_plus_one = smlsiz + 1;
- return 9*n + 2*n*smlsiz + 8*n*nlvl + 3*smlsiz*nrhs +
- smlsiz_plus_one * smlsiz_plus_one;
- }
-
- //
- // Static member function that returns the minimum size of
- // workspace-array iwork.
- //
- static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n,
- const std::ptrdiff_t nlvl ) {
- return 3*n*nlvl+11*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 lalsd_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for lalsd. Its overload differs for
-// * MatrixB&
-// * User-defined workspace
-//
-template< typename VectorD, typename VectorE, typename MatrixB,
- typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, VectorD& d, VectorE& e, MatrixB& b,
- const typename remove_imaginary< typename bindings::value_type<
- MatrixB >::type >::type rcond, fortran_int_t& rank,
- Workspace work ) {
- return lalsd_impl< typename bindings::value_type<
- MatrixB >::type >::invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- work );
-}
-
-//
-// Overloaded function for lalsd. Its overload differs for
-// * MatrixB&
-// * Default workspace-type (optimal)
-//
-template< typename VectorD, typename VectorE, typename MatrixB >
-inline typename boost::disable_if< detail::is_workspace< MatrixB >,
- std::ptrdiff_t >::type
-lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, VectorD& d, VectorE& e, MatrixB& b,
- const typename remove_imaginary< typename bindings::value_type<
- MatrixB >::type >::type rcond, fortran_int_t& rank ) {
- return lalsd_impl< typename bindings::value_type<
- MatrixB >::type >::invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- optimal_workspace() );
-}
-
-//
-// Overloaded function for lalsd. Its overload differs for
-// * const MatrixB&
-// * User-defined workspace
-//
-template< typename VectorD, typename VectorE, typename MatrixB,
- typename Workspace >
-inline typename boost::enable_if< detail::is_workspace< Workspace >,
- std::ptrdiff_t >::type
-lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, VectorD& d, VectorE& e, const MatrixB& b,
- const typename remove_imaginary< typename bindings::value_type<
- MatrixB >::type >::type rcond, fortran_int_t& rank,
- Workspace work ) {
- return lalsd_impl< typename bindings::value_type<
- MatrixB >::type >::invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- work );
-}
-
-//
-// Overloaded function for lalsd. Its overload differs for
-// * const MatrixB&
-// * Default workspace-type (optimal)
-//
-template< typename VectorD, typename VectorE, typename MatrixB >
-inline typename boost::disable_if< detail::is_workspace< MatrixB >,
- std::ptrdiff_t >::type
-lalsd( const char uplo, const fortran_int_t smlsiz,
- const fortran_int_t n, VectorD& d, VectorE& e, const MatrixB& b,
- const typename remove_imaginary< typename bindings::value_type<
- MatrixB >::type >::type rcond, fortran_int_t& rank ) {
- return lalsd_impl< typename bindings::value_type<
- MatrixB >::type >::invoke( uplo, smlsiz, n, d, e, b, rcond, rank,
- optimal_workspace() );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Deleted: sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp
==============================================================================
--- sandbox/numeric_bindings/boost/numeric/bindings/lapack/driver/largv.hpp 2010-06-20 16:53:47 EDT (Sun, 20 Jun 2010)
+++ (empty file)
@@ -1,306 +0,0 @@
-//
-// 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_DRIVER_LARGV_HPP
-#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_LARGV_HPP
-
-#include <boost/assert.hpp>
-#include <boost/numeric/bindings/begin.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_type.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 largv 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 largv( const fortran_int_t n, float* x,
- const fortran_int_t incx, float* y, const fortran_int_t incy,
- float* c, const fortran_int_t incc ) {
- fortran_int_t info(0);
- LAPACK_SLARGV( &n, x, &incx, y, &incy, c, &incc );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * double value-type.
-//
-inline std::ptrdiff_t largv( const fortran_int_t n, double* x,
- const fortran_int_t incx, double* y, const fortran_int_t incy,
- double* c, const fortran_int_t incc ) {
- fortran_int_t info(0);
- LAPACK_DLARGV( &n, x, &incx, y, &incy, c, &incc );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<float> value-type.
-//
-inline std::ptrdiff_t largv( const fortran_int_t n, std::complex<float>* x,
- const fortran_int_t incx, std::complex<float>* y,
- const fortran_int_t incy, float* c, const fortran_int_t incc ) {
- fortran_int_t info(0);
- LAPACK_CLARGV( &n, x, &incx, y, &incy, c, &incc );
- return info;
-}
-
-//
-// Overloaded function for dispatching to
-// * netlib-compatible LAPACK backend (the default), and
-// * complex<double> value-type.
-//
-inline std::ptrdiff_t largv( const fortran_int_t n, std::complex<double>* x,
- const fortran_int_t incx, std::complex<double>* y,
- const fortran_int_t incy, double* c, const fortran_int_t incc ) {
- fortran_int_t info(0);
- LAPACK_ZLARGV( &n, x, &incx, y, &incy, c, &incc );
- return info;
-}
-
-} // namespace detail
-
-//
-// Value-type based template class. Use this class if you need a type
-// for dispatching to largv.
-//
-template< typename Value, typename Enable = void >
-struct largv_impl {};
-
-//
-// This implementation is enabled if Value is a real type.
-//
-template< typename Value >
-struct largv_impl< Value, typename boost::enable_if< is_real< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename VectorViewX, typename VectorViewY,
- typename VectorViewC >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorViewX& x,
- VectorViewY& y, VectorViewC& c ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorViewX >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorViewY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorViewX >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorViewC >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorViewX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorViewY >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorViewC >::value) );
- BOOST_ASSERT( bindings::size(c) >= 1+(n-1)*bindings::stride(c) );
- BOOST_ASSERT( bindings::size(x) >= 1+(n-1)*bindings::stride(x) );
- BOOST_ASSERT( bindings::size(y) >= 1+(n-1)*bindings::stride(y) );
- return detail::largv( n, bindings::begin_value(x),
- bindings::stride(x), bindings::begin_value(y),
- bindings::stride(y), bindings::begin_value(c),
- bindings::stride(c) );
- }
-
-};
-
-//
-// This implementation is enabled if Value is a complex type.
-//
-template< typename Value >
-struct largv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > {
-
- typedef Value value_type;
- typedef typename remove_imaginary< Value >::type real_type;
-
- //
- // Static member function, that
- // * Deduces the required arguments for dispatching to LAPACK, and
- // * Asserts that most arguments make sense.
- //
- template< typename VectorViewX, typename VectorViewY,
- typename VectorViewC >
- static std::ptrdiff_t invoke( const fortran_int_t n, VectorViewX& x,
- VectorViewY& y, VectorViewC& c ) {
- namespace bindings = ::boost::numeric::bindings;
- BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
- typename bindings::value_type< VectorViewX >::type >::type,
- typename remove_const< typename bindings::value_type<
- VectorViewY >::type >::type >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorViewX >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorViewY >::value) );
- BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorViewC >::value) );
- BOOST_ASSERT( bindings::size(c) >= 1+(n-1)*bindings::stride(c) );
- BOOST_ASSERT( bindings::size(x) >= 1+(n-1)*bindings::stride(x) );
- BOOST_ASSERT( bindings::size(y) >= 1+(n-1)*bindings::stride(y) );
- return detail::largv( n, bindings::begin_value(x),
- bindings::stride(x), bindings::begin_value(y),
- bindings::stride(y), bindings::begin_value(c),
- bindings::stride(c) );
- }
-
-};
-
-
-//
-// 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 largv_impl classes. In the
-// documentation, most overloads are collapsed to avoid a large number of
-// prototypes which are very similar.
-//
-
-//
-// Overloaded function for largv. Its overload differs for
-// * VectorViewX&
-// * VectorViewY&
-// * VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n, VectorViewX& x,
- VectorViewY& y, VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * const VectorViewX&
-// * VectorViewY&
-// * VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n,
- const VectorViewX& x, VectorViewY& y, VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * VectorViewX&
-// * const VectorViewY&
-// * VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n, VectorViewX& x,
- const VectorViewY& y, VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * const VectorViewX&
-// * const VectorViewY&
-// * VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n,
- const VectorViewX& x, const VectorViewY& y, VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * VectorViewX&
-// * VectorViewY&
-// * const VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n, VectorViewX& x,
- VectorViewY& y, const VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * const VectorViewX&
-// * VectorViewY&
-// * const VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n,
- const VectorViewX& x, VectorViewY& y, const VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * VectorViewX&
-// * const VectorViewY&
-// * const VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n, VectorViewX& x,
- const VectorViewY& y, const VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-//
-// Overloaded function for largv. Its overload differs for
-// * const VectorViewX&
-// * const VectorViewY&
-// * const VectorViewC&
-//
-template< typename VectorViewX, typename VectorViewY, typename VectorViewC >
-inline std::ptrdiff_t largv( const fortran_int_t n,
- const VectorViewX& x, const VectorViewY& y, const VectorViewC& c ) {
- return largv_impl< typename bindings::value_type<
- VectorViewX >::type >::invoke( n, x, y, c );
-}
-
-} // namespace lapack
-} // namespace bindings
-} // namespace numeric
-} // namespace boost
-
-#endif

Date view	Thread view	Subject view	Author view

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