//
//  Copyright (c) 2003--2008
//  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_HEEVR_HPP
#define BOOST_NUMERIC_BINDINGS_LAPACK_HEEVR_HPP

#include <boost/utility/enable_if.hpp>
#include <boost/numeric/bindings/lapack/lapack.h>

namespace boost {
namespace numeric {
namespace bindings {
namespace lapack {

$DESCRIPTION

template< typename ValueType, typename Enable = void >
struct heevr_impl{};

// complex specialization
template< typename ValueType >
struct heevr_impl< ValueType, boost::enable_if< is_complex<ValueType>::type > {

    typedef typename ValueType value_type;
    typedef typename traits::type_traits<ValueType>::real_type real_type;

    // overloaded member functions to call lapack
    static void operator()( char const jobz, char const range, char const uplo,
            int const n, traits::complex_f* a, int const lda, float const vl,
            float const vu, int const il, int const iu, float const abstol,
            int& m, float* w, traits::complex_f* z, int const ldz, int* isuppz,
            traits::complex_f* work, int const lwork, float* rwork,
            int const lrwork, int* iwork, int const liwork, int& info ) {
        LAPACK_CHEEVR( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
                &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
                &ldz, isuppz, traits::complex_ptr(work), &lwork, rwork,
                &lrwork, iwork, &liwork, &info );
    }
    static void operator()( char const jobz, char const range, char const uplo,
            int const n, traits::complex_d* a, int const lda, double const vl,
            double const vu, int const il, int const iu, double const abstol,
            int& m, double* w, traits::complex_d* z, int const ldz,
            int* isuppz, traits::complex_d* work, int const lwork,
            double* rwork, int const lrwork, int* iwork, int const liwork,
            int& info ) {
        LAPACK_ZHEEVR( &jobz, &range, &uplo, &n, traits::complex_ptr(a), &lda,
                &vl, &vu, &il, &iu, &abstol, &m, w, traits::complex_ptr(z),
                &ldz, isuppz, traits::complex_ptr(work), &lwork, rwork,
                &lrwork, iwork, &liwork, &info );
    }

    // user-defined workspace specialization
    template< typename MatrixA, typename VectorW, typename MatrixZ,
            typename VectorISUPPZ, typename WORK, typename RWORK,
            typename IWORK >
    static void operator()( char const jobz, char const range, char const uplo,
            MatrixA& a, real_type const vl, real_type const vu, int const il,
            int const iu, real_type const abstol, int& m, VectorW& w,
            MatrixZ& z, VectorISUPPZ& isuppz, int& info, workspace3< WORK,
            RWORK, IWORK >& work ) {
        assert( jobz == 'N' || jobz == 'V' );
        assert( range == 'A' || range == 'V' || range == 'I' );
        assert( uplo == 'U' || uplo == 'L' );
        assert( traits::matrix_size2(a) >= 0 );
        assert( traits::leading_dimension(a) >= std::max(1,
               traits::matrix_size2(a)) );
        operator()( jobz, range, uplo, traits::matrix_size2(a),
                traits::matrix_storage(a), traits::leading_dimension(a), vl,
                vu, il, iu, abstol, m, traits::vector_storage(w),
                traits::matrix_storage(z), traits::leading_dimension(z),
                traits::vector_storage(isuppz), traits::vector_storage(work),
                traits::vector_size(work), traits::vector_storage(rwork),
                traits::vector_size(rwork), traits::vector_storage(iwork),
                traits::vector_size(iwork), info );
    }

    // minimal workspace specialization
    template< typename MatrixA, typename VectorW, typename MatrixZ,
            typename VectorISUPPZ >
    static void operator()( char const jobz, char const range, char const uplo,
            MatrixA& a, real_type const vl, real_type const vu, int const il,
            int const iu, real_type const abstol, int& m, VectorW& w,
            MatrixZ& z, VectorISUPPZ& isuppz, int& info,
            minimal_workspace& work ) {
    }

    // optimal workspace specialization
    template< typename MatrixA, typename VectorW, typename MatrixZ,
            typename VectorISUPPZ >
    static void operator()( char const jobz, char const range, char const uplo,
            MatrixA& a, real_type const vl, real_type const vu, int const il,
            int const iu, real_type const abstol, int& m, VectorW& w,
            MatrixZ& z, VectorISUPPZ& isuppz, int& info,
            optimal_workspace &work ) {
    }
};


}}}} // namespace boost::numeric::bindings::lapack

#endif