Example #1
0
inline integer_t sytrf( MatrixA& a, VectorIPIV& ipiv ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    sytrf_impl< value_type >::invoke( a, ipiv, info,
            optimal_workspace() );
    return info;
}
Example #2
0
inline typename boost::disable_if< detail::is_workspace< MatrixC >,
        std::ptrdiff_t >::type
ormtr( const Side side, const MatrixA& a, const VectorTAU& tau,
        MatrixC& c ) {
    return ormtr_impl< typename bindings::value_type<
            MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() );
}
Example #3
0
inline typename boost::disable_if< detail::is_workspace< VectorTAU >,
        std::ptrdiff_t >::type
gehrd( const fortran_int_t ilo, const fortran_int_t ihi,
        MatrixA& a, VectorTAU& tau ) {
    return gehrd_impl< typename bindings::value_type<
            MatrixA >::type >::invoke( ilo, ihi, a, tau, optimal_workspace() );
}
Example #4
0
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
        std::ptrdiff_t >::type
stevd( const char jobz, const fortran_int_t n, VectorD& d,
        VectorE& e, MatrixZ& z ) {
    return stevd_impl< typename bindings::value_type<
            VectorD >::type >::invoke( jobz, n, d, e, z, optimal_workspace() );
}
Example #5
0
inline integer_t syevd( char const jobz, MatrixA& a, VectorW& w ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    syevd_impl< value_type >::invoke( jobz, a, w, info,
            optimal_workspace() );
    return info;
}
Example #6
0
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() );
}
Example #7
0
inline integer_t hetrd( MatrixA& a, VectorD& d, VectorE& e,
        VectorTAU& tau ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    hetrd_impl< value_type >::invoke( a, d, e, tau, info,
            optimal_workspace() );
    return info;
}
Example #8
0
inline integer_t hegvd( integer_t const itype, char const jobz,
        integer_t const n, MatrixA& a, MatrixB& b, VectorW& w ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    hegvd_impl< value_type >::invoke( itype, jobz, n, a, b, w, info,
            optimal_workspace() );
    return info;
}
Example #9
0
inline integer_t sbev( char const jobz, integer_t const n,
        integer_t const kd, MatrixAB& ab, VectorW& w, MatrixZ& z ) {
    typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
    integer_t info(0);
    sbev_impl< value_type >::invoke( jobz, n, kd, ab, w, z, info,
            optimal_workspace() );
    return info;
}
Example #10
0
inline integer_t unmrq( char const side, char const trans,
        integer_t const k, MatrixA& a, VectorTAU& tau, MatrixC& c ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    unmrq_impl< value_type >::invoke( side, trans, k, a, tau, c, info,
            optimal_workspace() );
    return info;
}
Example #11
0
inline integer_t ungbr( char const vect, integer_t const m,
        integer_t const n, integer_t const k, MatrixA& a, VectorTAU& tau ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    ungbr_impl< value_type >::invoke( vect, m, n, k, a, tau, info,
            optimal_workspace() );
    return info;
}
Example #12
0
inline typename boost::disable_if< detail::is_workspace< MatrixC >,
        std::ptrdiff_t >::type
opmtr( const Side side, const char uplo, const VectorAP& ap,
        const VectorTAU& tau, MatrixC& c ) {
    return opmtr_impl< typename bindings::value_type<
            VectorAP >::type >::invoke( side, uplo, ap, tau, c,
            optimal_workspace() );
}
Example #13
0
inline typename boost::disable_if< detail::is_workspace< MatrixZ >,
        std::ptrdiff_t >::type
spgv( const fortran_int_t itype, const char jobz, MatrixAP& ap,
        MatrixBP& bp, VectorW& w, MatrixZ& z ) {
    return spgv_impl< typename bindings::value_type<
            MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z,
            optimal_workspace() );
}
Example #14
0
inline integer_t upgtr( char const uplo, VectorAP& ap, VectorTAU& tau,
        MatrixQ& q ) {
    typedef typename traits::vector_traits< VectorAP >::value_type value_type;
    integer_t info(0);
    upgtr_impl< value_type >::invoke( uplo, ap, tau, q, info,
            optimal_workspace() );
    return info;
}
Example #15
0
inline integer_t ggbal( char const job, integer_t const n, MatrixA& a,
        MatrixB& b, integer_t& ilo, integer_t& ihi, VectorLSCALE& lscale,
        VectorRSCALE& rscale ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    ggbal_impl< value_type >::invoke( job, n, a, b, ilo, ihi, lscale,
            rscale, info, optimal_workspace() );
    return info;
}
Example #16
0
inline integer_t sprfs( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
        VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
        VectorBERR& berr ) {
    typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
    integer_t info(0);
    sprfs_impl< value_type >::invoke( n, ap, afp, ipiv, b, x, ferr, berr,
            info, optimal_workspace() );
    return info;
}
Example #17
0
inline typename boost::disable_if< detail::is_workspace< VectorIQ >,
        std::ptrdiff_t >::type
bdsdc( const char uplo, const char compq, const fortran_int_t n,
        VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q,
        VectorIQ& iq ) {
    return bdsdc_impl< typename bindings::value_type<
            VectorD >::type >::invoke( uplo, compq, n, d, e, u, vt, q, iq,
            optimal_workspace() );
}
Example #18
0
inline integer_t hbtrd( char const vect, integer_t const n,
        integer_t const kd, MatrixAB& ab, VectorD& d, VectorE& e,
        MatrixQ& q ) {
    typedef typename traits::matrix_traits< MatrixAB >::value_type value_type;
    integer_t info(0);
    hbtrd_impl< value_type >::invoke( vect, n, kd, ab, d, e, q, info,
            optimal_workspace() );
    return info;
}
Example #19
0
inline integer_t spgv( integer_t const itype, char const jobz,
                       integer_t const n, MatrixAP& ap, MatrixBP& bp, VectorW& w,
                       MatrixZ& z ) {
    typedef typename traits::matrix_traits< MatrixAP >::value_type value_type;
    integer_t info(0);
    spgv_impl< value_type >::invoke( itype, jobz, n, ap, bp, w, z, info,
                                     optimal_workspace() );
    return info;
}
Example #20
0
inline typename boost::disable_if< detail::is_workspace< VectorTAU >,
        std::ptrdiff_t >::type
orgbr( const char vect, const fortran_int_t m,
        const fortran_int_t n, const fortran_int_t k, MatrixA& a,
        const VectorTAU& tau ) {
    return orgbr_impl< typename bindings::value_type<
            MatrixA >::type >::invoke( vect, m, n, k, a, tau,
            optimal_workspace() );
}
Example #21
0
    int sygv (int itype, char jobz, char uplo, A& a, B& b, W& w, Work work = optimal_workspace()) {

#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK 
      typedef typename A::value_type                               value_type ;
      typedef typename traits::type_traits< value_type >::real_type real_type ;
      BOOST_STATIC_ASSERT((boost::is_same<value_type, real_type>::value));
#endif

      return hegv (itype, jobz, uplo, a, b, w, work);
    }
Example #22
0
inline typename boost::disable_if< detail::is_workspace< VectorIPIV >,
        std::ptrdiff_t >::type
hpcon( const MatrixAP& ap, const VectorIPIV& ipiv,
        const typename remove_imaginary< typename bindings::value_type<
        MatrixAP >::type >::type anorm, typename remove_imaginary<
        typename bindings::value_type< MatrixAP >::type >::type& rcond ) {
    return hpcon_impl< typename bindings::value_type<
            MatrixAP >::type >::invoke( ap, ipiv, anorm, rcond,
            optimal_workspace() );
}
Example #23
0
inline typename boost::disable_if< detail::is_workspace< MatrixA >,
        std::ptrdiff_t >::type
gecon( const char norm, const MatrixA& a,
        const typename remove_imaginary< typename bindings::value_type<
        MatrixA >::type >::type anorm, typename remove_imaginary<
        typename bindings::value_type< MatrixA >::type >::type& rcond ) {
    return gecon_impl< typename bindings::value_type<
            MatrixA >::type >::invoke( norm, a, anorm, rcond,
            optimal_workspace() );
}
Example #24
0
inline typename boost::disable_if< detail::is_workspace< VectorE >,
        std::ptrdiff_t >::type
ptcon( const VectorD& d, const VectorE& e,
        const typename remove_imaginary< typename bindings::value_type<
        VectorE >::type >::type anorm, typename remove_imaginary<
        typename bindings::value_type< VectorE >::type >::type& rcond ) {
    return ptcon_impl< typename bindings::value_type<
            VectorE >::type >::invoke( d, e, anorm, rcond,
            optimal_workspace() );
}
Example #25
0
inline typename boost::disable_if< detail::is_workspace< VectorIFAILR >,
        std::ptrdiff_t >::type
hsein( const Side side, const char eigsrc, const char initv,
        const VectorSELECT& select, const MatrixH& h, VectorW& w,
        MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm,
        fortran_int_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr ) {
    return hsein_impl< typename bindings::value_type<
            MatrixH >::type >::invoke( side, eigsrc, initv, select, h, w, vl,
            vr, mm, m, ifaill, ifailr, optimal_workspace() );
}
Example #26
0
inline typename boost::disable_if< detail::is_workspace< VectorBERR >,
        std::ptrdiff_t >::type
pbsvx( const char fact, MatrixAB& ab, MatrixAFB& afb, char& equed,
        VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary<
        typename bindings::value_type< MatrixAB >::type >::type& rcond,
        VectorFERR& ferr, VectorBERR& berr ) {
    return pbsvx_impl< typename bindings::value_type<
            MatrixAB >::type >::invoke( fact, ab, afb, equed, s, b, x, rcond,
            ferr, berr, optimal_workspace() );
}
Example #27
0
inline integer_t posvx( char const fact, MatrixA& a, MatrixAF& af,
        char& equed, VectorS& s, MatrixB& b, MatrixX& x,
        typename traits::type_traits< typename traits::matrix_traits<
        MatrixA >::value_type >::real_type& rcond, VectorFERR& ferr,
        VectorBERR& berr ) {
    typedef typename traits::matrix_traits< MatrixA >::value_type value_type;
    integer_t info(0);
    posvx_impl< value_type >::invoke( fact, a, af, equed, s, b, x, rcond,
            ferr, berr, info, optimal_workspace() );
    return info;
}
Example #28
0
inline typename boost::disable_if< detail::is_workspace< MatrixQ >,
        std::ptrdiff_t >::type
tgsja( const char jobu, const char jobv, const char jobq,
        const fortran_int_t k, const fortran_int_t l, MatrixA& a,
        MatrixB& b, const typename remove_imaginary<
        typename bindings::value_type< MatrixA >::type >::type tola,
        const typename remove_imaginary< typename bindings::value_type<
        MatrixA >::type >::type tolb, VectorALPHA& alpha, VectorBETA& beta,
        MatrixU& u, MatrixV& v, MatrixQ& q, fortran_int_t& ncycle ) {
    return tgsja_impl< typename bindings::value_type<
            MatrixA >::type >::invoke( jobu, jobv, jobq, k, l, a, b, tola,
            tolb, alpha, beta, u, v, q, ncycle, optimal_workspace() );
}
Example #29
0
inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >,
        std::ptrdiff_t >::type
spevx( const char jobz, const char range, MatrixAP& ap,
        const typename remove_imaginary< typename bindings::value_type<
        MatrixAP >::type >::type vl, const typename remove_imaginary<
        typename bindings::value_type< MatrixAP >::type >::type vu,
        const fortran_int_t il, const fortran_int_t iu,
        const typename remove_imaginary< typename bindings::value_type<
        MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w,
        MatrixZ& z, VectorIFAIL& ifail ) {
    return spevx_impl< typename bindings::value_type<
            MatrixAP >::type >::invoke( jobz, range, ap, vl, vu, il, iu,
            abstol, m, w, z, ifail, optimal_workspace() );
}
Example #30
0
inline typename boost::disable_if< detail::is_workspace< VectorISPLIT >,
        std::ptrdiff_t >::type
stebz( const char range, const char order, const fortran_int_t n,
        const typename remove_imaginary< typename bindings::value_type<
        VectorD >::type >::type vl, const typename remove_imaginary<
        typename bindings::value_type< VectorD >::type >::type vu,
        const fortran_int_t il, const fortran_int_t iu,
        const typename remove_imaginary< typename bindings::value_type<
        VectorD >::type >::type abstol, const VectorD& d, const VectorE& e,
        fortran_int_t& m, fortran_int_t& nsplit, VectorW& w,
        VectorIBLOCK& iblock, VectorISPLIT& isplit ) {
    return stebz_impl< typename bindings::value_type<
            VectorD >::type >::invoke( range, order, n, vl, vu, il, iu,
            abstol, d, e, m, nsplit, w, iblock, isplit, optimal_workspace() );
}