Beispiel #1
0
 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 ) );
 }
Beispiel #2
0
 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 ) );
 }
Beispiel #3
0
 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 ) );
 }
Beispiel #4
0
 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 ) );
 }
Beispiel #5
0
 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 ) );
 }
Beispiel #6
0
 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 ) );
 }
Beispiel #7
0
 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 ) );
 }
Beispiel #8
0
 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 ) );
 }
Beispiel #9
0
 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 ) );
 }
Beispiel #10
0
 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 ) );
 }
Beispiel #11
0
 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 ) );
 }
Beispiel #12
0
 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 ) );
 }
Beispiel #13
0
 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 ) );
 }
Beispiel #14
0
 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 ) );
 }
Beispiel #15
0
 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 ) );
 }
Beispiel #16
0
 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 ) );
 }
Beispiel #17
0
 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 ) );
 }
Beispiel #18
0
 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 ) );
 }
Beispiel #19
0
 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 ) );
 }
Beispiel #20
0
 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 ) );
 }
Beispiel #21
0
 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 ) );
 }
Beispiel #22
0
 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 ) );
 }
Beispiel #23
0
 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 ) );
 }
Beispiel #24
0
 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 ) );
 }
Beispiel #25
0
 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 ) );
 }
Beispiel #26
0
 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 ) );
 }
Beispiel #27
0
 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 ) );
 }
Beispiel #28
0
 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 ) );
 }
Beispiel #29
0
 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 ) );
 }
Beispiel #30
0
 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 ) );
 }