static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, MatrixA& a, const VectorTAU& tau, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( m, n ) ); return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( MatrixA& a, const 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 std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef typename result_of::uplo_tag< MatrixA >::type uplo; bindings::detail::array< value_type > tmp_work( min_size_work() ); return invoke( a, ipiv, b, workspace( tmp_work ) ); }

static void invoke( char const vect, char const side, char const trans, integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c, integer_t& info, minimal_workspace work ) { traits::detail::array< real_type > tmp_work( min_size_work( side, traits::matrix_num_rows(c), traits::matrix_num_columns(c) ) ); invoke( vect, side, trans, k, a, tau, c, info, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( norm, bindings::size_column(ab) ) ); return invoke( norm, ab, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( bindings::size(d) ) ); return invoke( compz, d, e, z, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, const real_type anorm, real_type& rcond, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( bindings::size(d) ) ); return invoke( d, e, anorm, rcond, workspace( tmp_work ) ); }

static void invoke( char const job, integer_t const n, MatrixA& a, MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale, integer_t& info, minimal_workspace work ) { traits::detail::array< real_type > tmp_work( min_size_work( $CALL_MIN_SIZE ) ); invoke( job, n, a, b, ilo, ihi, lscale, rscale, info, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef typename result_of::uplo_tag< MatrixAP >::type uplo; bindings::detail::array< value_type > tmp_work( min_size_work( bindings::size_column(ap) ) ); return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work ) ); }

static void invoke( char const compz, integer_t const n, VectorD& d, VectorE& e, MatrixZ& z, integer_t& info, minimal_workspace work ) { traits::detail::array< real_type > tmp_work( min_size_work( $CALL_MIN_SIZE ) ); traits::detail::array< integer_t > tmp_iwork( min_size_iwork( compz, n ) ); invoke( compz, n, d, e, z, info, workspace( tmp_work, tmp_iwork ) ); }

static std::ptrdiff_t invoke( const fortran_int_t n, const fortran_int_t ilo, const fortran_int_t ihi, MatrixA& a, const VectorTAU& tau, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( ihi, ilo ) ); return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); }

static void invoke( char const jobz, MatrixA& a, VectorW& w, integer_t& info, minimal_workspace work ) { traits::detail::array< real_type > tmp_work( min_size_work( jobz, traits::matrix_num_columns(a) ) ); traits::detail::array< integer_t > tmp_iwork( min_size_iwork( jobz, traits::matrix_num_columns(a) ) ); invoke( jobz, a, w, info, workspace( tmp_work, tmp_iwork ) ); }

static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp, VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, integer_t& info, minimal_workspace work ) { traits::detail::array< value_type > tmp_work( min_size_work( n ) ); traits::detail::array< real_type > tmp_rwork( min_size_rwork( n ) ); invoke( n, ap, afp, ipiv, b, x, ferr, berr, info, workspace( tmp_work, tmp_rwork ) ); }

static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef typename result_of::uplo_tag< MatrixAP >::type uplo; bindings::detail::array< real_type > tmp_work( min_size_work( norm, bindings::size_column(ap) ) ); return invoke( norm, ap, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef typename result_of::uplo_tag< MatrixAB >::type uplo; bindings::detail::array< real_type > tmp_work( min_size_work( bindings::size_column(ab) ) ); return invoke( jobz, ab, w, z, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const Side side, const MatrixA& a, const VectorTAU& tau, MatrixC& c, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef typename result_of::data_order< MatrixC >::type order; typedef typename result_of::trans_tag< MatrixA, order >::type trans; bindings::detail::array< real_type > tmp_work( min_size_work( side, bindings::size_row(c), bindings::size_column(c) ) ); return invoke( side, a, tau, c, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( jobz, n ) ); bindings::detail::array< fortran_int_t > tmp_iwork( min_size_iwork( jobz, n ) ); return invoke( jobz, n, d, e, z, workspace( tmp_work, tmp_iwork ) ); }

static std::ptrdiff_t invoke( const fortran_int_t itype, const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, MatrixZ& z, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef typename result_of::uplo_tag< MatrixAP >::type uplo; bindings::detail::array< real_type > tmp_work( min_size_work( bindings::size_column(ap) ) ); return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const Side side, const char uplo, const VectorAP& ap, const VectorTAU& tau, MatrixC& c, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; typedef tag::column_major order; typedef typename result_of::trans_tag< VectorAP, order >::type trans; bindings::detail::array< real_type > tmp_work( min_size_work( side, bindings::size_row(c), bindings::size_column(c) ) ); return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const char norm, const MatrixA& a, const real_type anorm, real_type& rcond, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< value_type > tmp_work( min_size_work( bindings::size_column(a) ) ); bindings::detail::array< real_type > tmp_rwork( min_size_rwork( bindings::size_column(a) ) ); return invoke( norm, a, anorm, rcond, workspace( tmp_work, tmp_rwork ) ); }

static void invoke( MatrixA& a, VectorIPIV& ipiv, integer_t& info, optimal_workspace work ) { value_type opt_size_work; detail::sytrf( traits::matrix_uplo_tag(a), traits::matrix_num_columns(a), traits::matrix_storage(a), traits::leading_dimension(a), traits::vector_storage(ipiv), &opt_size_work, -1, info ); traits::detail::array< value_type > tmp_work( traits::detail::to_int( opt_size_work ) ); invoke( a, ipiv, info, workspace( tmp_work ) ); }

static void invoke( char const range, char const order, integer_t const n, real_type const vl, real_type const vu, integer_t const il, integer_t const iu, real_type const abstol, VectorD& d, VectorE& e, integer_t& m, integer_t& nsplit, VectorW& w, VectorIBLOCK& iblock, VectorISPLIT& isplit, integer_t& info, minimal_workspace work ) { traits::detail::array< real_type > tmp_work( min_size_work( n ) ); traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) ); invoke( range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, info, workspace( tmp_work, tmp_iwork ) ); }

static void invoke( char const jobz, char const range, integer_t const n, integer_t const ka, integer_t const kb, MatrixAB& ab, MatrixBB& bb, MatrixQ& q, real_type const vl, real_type const vu, integer_t const il, integer_t const iu, real_type const abstol, integer_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, integer_t& info, minimal_workspace work ) { traits::detail::array< real_type > tmp_work( min_size_work( n ) ); traits::detail::array< integer_t > tmp_iwork( min_size_iwork( n ) ); invoke( jobz, range, n, ka, kb, ab, bb, q, vl, vu, il, iu, abstol, m, w, z, ifail, info, workspace( tmp_work, tmp_iwork ) ); }

static void invoke( MatrixA& a, VectorTAU& tau, integer_t& info, optimal_workspace work ) { value_type opt_size_work; detail::geqrf( traits::matrix_num_rows(a), traits::matrix_num_columns(a), traits::matrix_storage(a), traits::leading_dimension(a), traits::vector_storage(tau), &opt_size_work, -1, info ); traits::detail::array< value_type > tmp_work( traits::detail::to_int( opt_size_work ) ); invoke( a, tau, info, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, optimal_workspace ) { namespace bindings = ::boost::numeric::bindings; value_type opt_size_work; detail::geqrf( bindings::size_row(a), bindings::size_column(a), bindings::begin_value(a), bindings::stride_major(a), bindings::begin_value(tau), &opt_size_work, -1 ); bindings::detail::array< value_type > tmp_work( traits::detail::to_int( opt_size_work ) ); return invoke( a, tau, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const Side side, const char eigsrc, const char initv, VectorSELECT& select, const MatrixH& h, VectorWR& wr, const VectorWI& wi, MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( bindings::size_column(h) ) ); return invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, ifaill, ifailr, workspace( tmp_work ) ); }

static void invoke( char const vect, integer_t const m, integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau, integer_t& info, optimal_workspace work ) { value_type opt_size_work; detail::ungbr( vect, m, n, k, traits::matrix_storage(a), traits::leading_dimension(a), traits::vector_storage(tau), &opt_size_work, -1, info ); traits::detail::array< value_type > tmp_work( traits::detail::to_int( opt_size_work ) ); invoke( vect, m, n, k, a, tau, info, workspace( tmp_work ) ); }

static std::ptrdiff_t invoke( const char uplo, const char compq, const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q, VectorIQ& iq, minimal_workspace ) { namespace bindings = ::boost::numeric::bindings; bindings::detail::array< real_type > tmp_work( min_size_work( compq, n ) ); bindings::detail::array< fortran_int_t > tmp_iwork( min_size_iwork( n ) ); return invoke( uplo, compq, n, d, e, u, vt, q, iq, workspace( tmp_work, tmp_iwork ) ); }

static void invoke( char const fact, MatrixA& a, MatrixAF& af, char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, integer_t& info, minimal_workspace work ) { traits::detail::array< value_type > tmp_work( min_size_work( traits::matrix_num_columns(a) ) ); traits::detail::array< real_type > tmp_rwork( min_size_rwork( traits::matrix_num_columns(a) ) ); invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr, info, workspace( tmp_work, tmp_rwork ) ); }

static void invoke( integer_t const itype, char const jobz, integer_t const n, MatrixA& a, MatrixB& b, VectorW& w, integer_t& info, minimal_workspace work ) { traits::detail::array< value_type > tmp_work( min_size_work( jobz, n ) ); traits::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, n ) ); traits::detail::array< integer_t > tmp_iwork( min_size_iwork( jobz, n ) ); invoke( itype, jobz, n, a, b, w, info, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); }