static void invoke( char const jobz, char const range, MatrixA& a,
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,
detail::workspace3< WORK, RWORK, IWORK > work ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixA >::value_type, typename traits::matrix_traits<
MatrixZ >::value_type >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' );
BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
traits::matrix_uplo_tag(a) == 'L' );
BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
traits::matrix_num_columns(a)) );
BOOST_ASSERT( traits::vector_size(w) >=
traits::matrix_num_columns(a) );
BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
min_size_work( traits::matrix_num_columns(a) ));
BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
min_size_rwork( traits::matrix_num_columns(a) ));
BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
min_size_iwork( traits::matrix_num_columns(a) ));
detail::heevx( jobz, range, traits::matrix_uplo_tag(a),
traits::matrix_num_columns(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(work.select(value_type())),
traits::vector_size(work.select(value_type())),
traits::vector_storage(work.select(real_type())),
traits::vector_storage(work.select(integer_t())),
traits::vector_storage(ifail), info );
}
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_rwork( min_size_rwork(
bindings::size(d) ) );
return invoke( d, e, anorm, rcond, workspace( 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, detail::workspace3< WORK, RWORK, IWORK > work ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixA >::value_type, typename traits::matrix_traits<
MatrixB >::value_type >::value) );
BOOST_ASSERT( jobz == 'N' || jobz == 'V' );
BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
traits::matrix_uplo_tag(a) == 'L' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,n) );
BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
min_size_work( jobz, n ));
BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
min_size_rwork( jobz, n ));
BOOST_ASSERT( traits::vector_size(work.select(integer_t())) >=
min_size_iwork( jobz, n ));
detail::hegvd( itype, jobz, traits::matrix_uplo_tag(a), n,
traits::matrix_storage(a), traits::leading_dimension(a),
traits::matrix_storage(b), traits::leading_dimension(b),
traits::vector_storage(w),
traits::vector_storage(work.select(value_type())),
traits::vector_size(work.select(value_type())),
traits::vector_storage(work.select(real_type())),
traits::vector_size(work.select(real_type())),
traits::vector_storage(work.select(integer_t())),
traits::vector_size(work.select(integer_t())), info );
}
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 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, detail::workspace2<
WORK, RWORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) );
BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) );
BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename bindings::value_type< VectorIFAILL >::type >::type,
typename remove_const< typename bindings::value_type<
VectorIFAILR >::type >::type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename bindings::value_type< MatrixH >::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< MatrixH >::type >::type,
typename remove_const< typename bindings::value_type<
MatrixVL >::type >::type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const<
typename bindings::value_type< MatrixH >::type >::type,
typename remove_const< typename bindings::value_type<
MatrixVR >::type >::type >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILL >::value) );
BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILR >::value) );
BOOST_ASSERT( bindings::size(select) >= bindings::size_column(h) );
BOOST_ASSERT( bindings::size(w) >= bindings::size_column(h) );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
min_size_rwork( bindings::size_column(h) ));
BOOST_ASSERT( bindings::size(work.select(value_type())) >=
min_size_work( bindings::size_column(h) ));
BOOST_ASSERT( bindings::size_column(h) >= 0 );
BOOST_ASSERT( bindings::size_minor(h) == 1 ||
bindings::stride_minor(h) == 1 );
BOOST_ASSERT( bindings::size_minor(vl) == 1 ||
bindings::stride_minor(vl) == 1 );
BOOST_ASSERT( bindings::size_minor(vr) == 1 ||
bindings::stride_minor(vr) == 1 );
BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1,
bindings::size_column(h)) );
BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
BOOST_ASSERT( initv == 'N' || initv == 'U' );
return detail::hsein( side, eigsrc, initv,
bindings::begin_value(select), bindings::size_column(h),
bindings::begin_value(h), bindings::stride_major(h),
bindings::begin_value(w), bindings::begin_value(vl),
bindings::stride_major(vl), bindings::begin_value(vr),
bindings::stride_major(vr), mm, m,
bindings::begin_value(work.select(value_type())),
bindings::begin_value(work.select(real_type())),
bindings::begin_value(ifaill), bindings::begin_value(ifailr) );
}
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( 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 ) );
}
static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e,
const real_type anorm, real_type& rcond, detail::workspace1<
RWORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_ASSERT( bindings::size(d) >= bindings::size(d) );
BOOST_ASSERT( bindings::size(d) >= 0 );
BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
min_size_rwork( bindings::size(d) ));
return detail::ptcon( bindings::size(d), bindings::begin_value(d),
bindings::begin_value(e), anorm, rcond,
bindings::begin_value(work.select(real_type())) );
}
static std::ptrdiff_t invoke( 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, minimal_workspace ) {
namespace bindings = ::boost::numeric::bindings;
bindings::detail::array< value_type > tmp_work( min_size_work(
bindings::size_column(h) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
bindings::size_column(h) ) );
return invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m,
ifaill, ifailr, workspace( tmp_work, tmp_rwork ) );
}
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,
minimal_workspace ) {
namespace bindings = ::boost::numeric::bindings;
typedef typename result_of::uplo_tag< MatrixAB >::type uplo;
bindings::detail::array< value_type > tmp_work( min_size_work(
bindings::size_column(ab) ) );
bindings::detail::array< real_type > tmp_rwork( min_size_rwork(
bindings::size_column(ab) ) );
return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr,
workspace( tmp_work, tmp_rwork ) );
}
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,
detail::workspace2< WORK, RWORK > work ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
VectorS >::value_type, typename traits::vector_traits<
VectorFERR >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
VectorS >::value_type, typename traits::vector_traits<
VectorBERR >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixA >::value_type, typename traits::matrix_traits<
MatrixAF >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixA >::value_type, typename traits::matrix_traits<
MatrixB >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixA >::value_type, typename traits::matrix_traits<
MatrixX >::value_type >::value) );
BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' ||
fact == 'E' );
BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
traits::matrix_uplo_tag(a) == 'L' );
BOOST_ASSERT( traits::matrix_num_columns(a) >= 0 );
BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
BOOST_ASSERT( traits::leading_dimension(a) >= std::max(1,
traits::matrix_num_columns(a)) );
BOOST_ASSERT( traits::leading_dimension(af) >= std::max(1,
traits::matrix_num_columns(a)) );
BOOST_ASSERT( equed == 'N' || equed == 'Y' );
BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,
traits::matrix_num_columns(a)) );
BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,
traits::matrix_num_columns(a)) );
BOOST_ASSERT( traits::vector_size(berr) >=
traits::matrix_num_columns(x) );
BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
min_size_work( traits::matrix_num_columns(a) ));
BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
min_size_rwork( traits::matrix_num_columns(a) ));
detail::posvx( fact, traits::matrix_uplo_tag(a),
traits::matrix_num_columns(a), traits::matrix_num_columns(x),
traits::matrix_storage(a), traits::leading_dimension(a),
traits::matrix_storage(af), traits::leading_dimension(af),
equed, traits::vector_storage(s), traits::matrix_storage(b),
traits::leading_dimension(b), traits::matrix_storage(x),
traits::leading_dimension(x), rcond,
traits::vector_storage(ferr), traits::vector_storage(berr),
traits::vector_storage(work.select(value_type())),
traits::vector_storage(work.select(real_type())), info );
}
static void invoke( char const jobz, char const range, MatrixA& a,
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< 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) ) );
traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
traits::matrix_num_columns(a) ) );
invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, info,
workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
static std::ptrdiff_t invoke( const char norm, const MatrixA& a,
const real_type anorm, real_type& rcond, detail::workspace2< WORK,
RWORK > work ) {
namespace bindings = ::boost::numeric::bindings;
BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) );
BOOST_ASSERT( bindings::size(work.select(real_type())) >=
min_size_rwork( bindings::size_column(a) ));
BOOST_ASSERT( bindings::size(work.select(value_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(value_type())),
bindings::begin_value(work.select(real_type())) );
}
static void invoke( integer_t const n, MatrixAP& ap, MatrixAFP& afp,
VectorIPIV& ipiv, MatrixB& b, MatrixX& x, VectorFERR& ferr,
VectorBERR& berr, integer_t& info, detail::workspace2< WORK,
RWORK > work ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
VectorFERR >::value_type, typename traits::vector_traits<
VectorBERR >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixAP >::value_type, typename traits::matrix_traits<
MatrixAFP >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixAP >::value_type, typename traits::matrix_traits<
MatrixB >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixAP >::value_type, typename traits::matrix_traits<
MatrixX >::value_type >::value) );
BOOST_ASSERT( traits::matrix_uplo_tag(a) == 'U' ||
traits::matrix_uplo_tag(a) == 'L' );
BOOST_ASSERT( n >= 0 );
BOOST_ASSERT( traits::matrix_num_columns(x) >= 0 );
BOOST_ASSERT( traits::vector_size(afp) >= n*(n+1)/2 );
BOOST_ASSERT( traits::vector_size(ipiv) >= n );
BOOST_ASSERT( traits::leading_dimension(b) >= std::max(1,n) );
BOOST_ASSERT( traits::leading_dimension(x) >= std::max(1,n) );
BOOST_ASSERT( traits::vector_size(berr) >=
traits::matrix_num_columns(x) );
BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
min_size_work( n ));
BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
min_size_rwork( n ));
detail::sprfs( traits::matrix_uplo_tag(a), n,
traits::matrix_num_columns(x), traits::matrix_storage(ap),
traits::matrix_storage(afp), traits::vector_storage(ipiv),
traits::matrix_storage(b), traits::leading_dimension(b),
traits::matrix_storage(x), traits::leading_dimension(x),
traits::vector_storage(ferr), traits::vector_storage(berr),
traits::vector_storage(work.select(value_type())),
traits::vector_storage(work.select(real_type())), info );
}
static void invoke( char const jobz, char const range, MatrixA& a,
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,
optimal_workspace work ) {
value_type opt_size_work;
traits::detail::array< real_type > tmp_rwork( min_size_rwork(
traits::matrix_num_columns(a) ) );
traits::detail::array< integer_t > tmp_iwork( min_size_iwork(
traits::matrix_num_columns(a) ) );
detail::heevx( jobz, range, traits::matrix_uplo_tag(a),
traits::matrix_num_columns(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), &opt_size_work, -1,
traits::vector_storage(tmp_rwork),
traits::vector_storage(tmp_iwork),
traits::vector_storage(ifail), info );
traits::detail::array< value_type > tmp_work(
traits::detail::to_int( opt_size_work ) );
invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, info,
workspace( tmp_work, tmp_rwork, tmp_iwork ) );
}
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, RWORK > 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< VectorS >::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< VectorS >::type >::type,
typename remove_const< typename bindings::value_type<
VectorBERR >::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<
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<
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( (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(real_type())) >=
min_size_rwork( bindings::size_column(ab) ));
BOOST_ASSERT( bindings::size(work.select(value_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(value_type())),
bindings::begin_value(work.select(real_type())) );
}