Ejemplo n.º 1
0
 static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n,
         VectorD& d, VectorE& e, MatrixZ& z, detail::workspace2< WORK,
         IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::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<
             MatrixZ >::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< MatrixZ >::value) );
     BOOST_ASSERT( bindings::size(e) >= n-1 );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( jobz, n ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( jobz, n ));
     BOOST_ASSERT( bindings::size_minor(z) == 1 ||
             bindings::stride_minor(z) == 1 );
     BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
     BOOST_ASSERT( n >= 0 );
     return detail::stevd( jobz, n, bindings::begin_value(d),
             bindings::begin_value(e), bindings::begin_value(z),
             bindings::stride_major(z),
             bindings::begin_value(work.select(real_type())),
             bindings::size(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())),
             bindings::size(work.select(fortran_int_t())) );
 }
Ejemplo n.º 2
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, detail::workspace2< WORK,
         IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::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<
             MatrixU >::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<
             MatrixVT >::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<
             VectorQ >::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< MatrixU >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorQ >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIQ >::value) );
     BOOST_ASSERT( bindings::size(e) >= n-1 );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( n ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( compq, n ));
     BOOST_ASSERT( bindings::size_minor(u) == 1 ||
             bindings::stride_minor(u) == 1 );
     BOOST_ASSERT( bindings::size_minor(vt) == 1 ||
             bindings::stride_minor(vt) == 1 );
     BOOST_ASSERT( compq == 'N' || compq == 'P' || compq == 'I' );
     BOOST_ASSERT( n >= 0 );
     return detail::bdsdc( uplo, compq, n, bindings::begin_value(d),
             bindings::begin_value(e), bindings::begin_value(u),
             bindings::stride_major(u), bindings::begin_value(vt),
             bindings::stride_major(vt), bindings::begin_value(q),
             bindings::begin_value(iq),
             bindings::begin_value(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())) );
 }
Ejemplo n.º 3
0
 static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv,
         const real_type anorm, real_type& rcond, detail::workspace2< WORK,
         IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
     BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( bindings::size_column(ap) ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( bindings::size_column(ap) ));
     BOOST_ASSERT( bindings::size_column(ap) >= 0 );
     return detail::hpcon( uplo(), bindings::size_column(ap),
             bindings::begin_value(ap), bindings::begin_value(ipiv), anorm,
             rcond, bindings::begin_value(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())) );
 }
Ejemplo n.º 4
0
 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 );
 }
Ejemplo n.º 5
0
 static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
         const real_type anorm, real_type& rcond, detail::workspace2< WORK,
         IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( bindings::size_column(a) ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( bindings::size_column(a) ));
     BOOST_ASSERT( bindings::size_column(a) >= 0 );
     BOOST_ASSERT( bindings::size_minor(a) == 1 ||
             bindings::stride_minor(a) == 1 );
     BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1,
             bindings::size_column(a)) );
     BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' );
     return detail::gecon( norm, bindings::size_column(a),
             bindings::begin_value(a), bindings::stride_major(a), anorm,
             rcond, bindings::begin_value(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())) );
 }
Ejemplo n.º 6
0
 static std::ptrdiff_t invoke( const char range, const char order,
         const fortran_int_t n, const real_type vl, const real_type vu,
         const fortran_int_t il, const fortran_int_t iu,
         const real_type abstol, const VectorD& d, const VectorE& e,
         fortran_int_t& m, fortran_int_t& nsplit, VectorW& w,
         VectorIBLOCK& iblock, VectorISPLIT& isplit, detail::workspace2<
         WORK, IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     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<
             VectorW >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< VectorIBLOCK >::type >::type,
             typename remove_const< typename bindings::value_type<
             VectorISPLIT >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIBLOCK >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISPLIT >::value) );
     BOOST_ASSERT( bindings::size(d) >= n );
     BOOST_ASSERT( bindings::size(e) >= n-1 );
     BOOST_ASSERT( bindings::size(isplit) >= n );
     BOOST_ASSERT( bindings::size(w) >= n );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( n ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( n ));
     BOOST_ASSERT( n >= 0 );
     BOOST_ASSERT( order == 'B' || order == 'E' );
     BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
     return detail::stebz( range, order, n, vl, vu, il, iu, abstol,
             bindings::begin_value(d), bindings::begin_value(e), m, nsplit,
             bindings::begin_value(w), bindings::begin_value(iblock),
             bindings::begin_value(isplit),
             bindings::begin_value(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())) );
 }
Ejemplo n.º 7
0
 static std::ptrdiff_t invoke( const char jobz, const char range,
         MatrixAP& ap, const real_type vl, const real_type vu,
         const fortran_int_t il, const fortran_int_t iu,
         const real_type abstol, fortran_int_t& m, VectorW& w,
         MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK,
         IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAP >::type uplo;
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAP >::type >::type,
             typename remove_const< typename bindings::value_type<
             VectorW >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAP >::type >::type,
             typename remove_const< typename bindings::value_type<
             MatrixZ >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( bindings::size_column(ap) ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( bindings::size_column(ap) ));
     BOOST_ASSERT( bindings::size_column(ap) >= 0 );
     BOOST_ASSERT( bindings::size_minor(z) == 1 ||
             bindings::stride_minor(z) == 1 );
     BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
     BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
     return detail::spevx( jobz, range, uplo(), bindings::size_column(ap),
             bindings::begin_value(ap), vl, vu, il, iu, abstol, m,
             bindings::begin_value(w), bindings::begin_value(z),
             bindings::stride_major(z),
             bindings::begin_value(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())),
             bindings::begin_value(ifail) );
 }
Ejemplo n.º 8
0
 static std::ptrdiff_t invoke( const char fact, MatrixAB& ab,
         MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x,
         real_type& rcond, VectorFERR& ferr, VectorBERR& berr,
         detail::workspace2< WORK, IWORK > work ) {
     namespace bindings = ::boost::numeric::bindings;
     typedef typename result_of::uplo_tag< MatrixAB >::type uplo;
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAFB >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAB >::type >::type,
             typename remove_const< typename bindings::value_type<
             MatrixAFB >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAB >::type >::type,
             typename remove_const< typename bindings::value_type<
             VectorS >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAB >::type >::type,
             typename remove_const< typename bindings::value_type<
             MatrixB >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAB >::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< MatrixAB >::type >::type,
             typename remove_const< typename bindings::value_type<
             VectorFERR >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
             typename bindings::value_type< MatrixAB >::type >::type,
             typename remove_const< typename bindings::value_type<
             VectorBERR >::type >::type >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) );
     BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) );
     BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 );
     BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) );
     BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >=
             min_size_iwork( bindings::size_column(ab) ));
     BOOST_ASSERT( bindings::size(work.select(real_type())) >=
             min_size_work( bindings::size_column(ab) ));
     BOOST_ASSERT( bindings::size_column(ab) >= 0 );
     BOOST_ASSERT( bindings::size_column(b) >= 0 );
     BOOST_ASSERT( bindings::size_minor(ab) == 1 ||
             bindings::stride_minor(ab) == 1 );
     BOOST_ASSERT( bindings::size_minor(afb) == 1 ||
             bindings::stride_minor(afb) == 1 );
     BOOST_ASSERT( bindings::size_minor(b) == 1 ||
             bindings::stride_minor(b) == 1 );
     BOOST_ASSERT( bindings::size_minor(x) == 1 ||
             bindings::stride_minor(x) == 1 );
     BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab,
             uplo())+1 );
     BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab,
             uplo())+1 );
     BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1,
             bindings::size_column(ab)) );
     BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1,
             bindings::size_column(ab)) );
     BOOST_ASSERT( equed == 'N' || equed == 'Y' );
     BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
             fact == 'E' );
     return detail::pbsvx( fact, uplo(), bindings::size_column(ab),
             bindings::bandwidth(ab, uplo()), bindings::size_column(b),
             bindings::begin_value(ab), bindings::stride_major(ab),
             bindings::begin_value(afb), bindings::stride_major(afb),
             equed, bindings::begin_value(s), bindings::begin_value(b),
             bindings::stride_major(b), bindings::begin_value(x),
             bindings::stride_major(x), rcond, bindings::begin_value(ferr),
             bindings::begin_value(berr),
             bindings::begin_value(work.select(real_type())),
             bindings::begin_value(work.select(fortran_int_t())) );
 }