Bayesian Filtering Library
Generated from SVN r
|
main namespace of uBLAS. More...
Typedefs | |
typedef basic_range | range |
typedef basic_slice | slice |
typedef basic_row_major | row_major |
typedef basic_column_major | column_major |
typedef basic_full | full |
typedef basic_lower | lower |
typedef basic_upper | upper |
typedef basic_unit_lower | unit_lower |
typedef basic_unit_upper | unit_upper |
typedef basic_strict_lower | strict_lower |
typedef basic_strict_upper | strict_upper |
typedef nonassignable_::nonassignable | nonassignable |
Functions | |
template<class C > | |
BOOST_UBLAS_INLINE noalias_proxy< C > | noalias (C &lvalue) |
template<class C > | |
BOOST_UBLAS_INLINE noalias_proxy< const C > | noalias (const C &lvalue) |
template<class C > | |
BOOST_UBLAS_INLINE C & | safe (C &lvalue) |
template<class C > | |
BOOST_UBLAS_INLINE const C & | safe (const C &lvalue) |
template<class T1 , class T2 > | |
BOOST_UBLAS_INLINE T1 | same_impl_ex (const T1 &size1, const T2 &size2, const char *file, int line) |
template<class T > | |
BOOST_UBLAS_INLINE T | same_impl_ex (const T &size1, const T &size2, const char *file, int line) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator+ (I in1, std::complex< R > const &in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator+ (std::complex< R > const &in1, I in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator- (I in1, std::complex< R > const &in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator- (std::complex< R > const &in1, I in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator* (I in1, std::complex< R > const &in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator* (std::complex< R > const &in1, I in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator/ (I in1, std::complex< R > const &in2) |
template<typename R , typename I > | |
boost::enable_if< mpl::and_< boost::is_float< R >, boost::is_integral< I > >, std::complex< R > >::type | operator/ (std::complex< R > const &in1, I in2) |
template<class I > | |
BOOST_UBLAS_INLINE void | increment (I &it, const I &it_end, typename I::difference_type compare, packed_random_access_iterator_tag) |
template<class I > | |
BOOST_UBLAS_INLINE void | increment (I &it, const I &, typename I::difference_type, sparse_bidirectional_iterator_tag) |
template<class I > | |
BOOST_UBLAS_INLINE void | increment (I &it, const I &it_end, typename I::difference_type compare) |
template<class I > | |
BOOST_UBLAS_INLINE void | increment (I &it, const I &it_end) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_negate< typename E::value_type > >::result_type | operator- (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_conj< typename E::value_type > >::result_type | conj (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_real< typename E::value_type > >::result_type | real (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_imag< typename E::value_type > >::result_type | imag (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< const E, scalar_identity< typename E::value_type > >::result_type | trans (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_identity< typename E::value_type > >::result_type | trans (vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_conj< typename E::value_type > >::result_type | herm (const vector_expression< E > &e) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_binary_traits< E1, E2, scalar_plus< typename E1::value_type, typename E2::value_type > >::result_type | operator+ (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_binary_traits< E1, E2, scalar_minus< typename E1::value_type, typename E2::value_type > >::result_type | operator- (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_binary_traits< E1, E2, scalar_multiplies< typename E1::value_type, typename E2::value_type > >::result_type | element_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_binary_traits< E1, E2, scalar_divides< typename E1::value_type, typename E2::value_type > >::result_type | element_div (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class T1 , class E2 > | |
BOOST_UBLAS_INLINE enable_if< is_convertible< T1, typename E2::value_type >, typename vector_binary_scalar1_traits< const T1, E2, scalar_multiplies< T1, typename E2::value_type > >::result_type >::type | operator* (const T1 &e1, const vector_expression< E2 > &e2) |
template<class E1 , class T2 > | |
BOOST_UBLAS_INLINE enable_if< is_convertible< T2, typename E1::value_type >, typename vector_binary_scalar2_traits< E1, const T2, scalar_multiplies< typename E1::value_type, T2 > >::result_type >::type | operator* (const vector_expression< E1 > &e1, const T2 &e2) |
template<class E1 , class T2 > | |
BOOST_UBLAS_INLINE enable_if< is_convertible< T2, typename E1::value_type >, typename vector_binary_scalar2_traits< E1, const T2, scalar_divides< typename E1::value_type, T2 > >::result_type >::type | operator/ (const vector_expression< E1 > &e1, const T2 &e2) |
template<class E > | |
BOOST_UBLAS_INLINE vector_scalar_unary_traits< E, vector_sum< E > >::result_type | sum (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_scalar_unary_traits< E, vector_norm_1< E > >::result_type | norm_1 (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_scalar_unary_traits< E, vector_norm_2< E > >::result_type | norm_2 (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_scalar_unary_traits< E, vector_norm_inf< E > >::result_type | norm_inf (const vector_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE vector_scalar_unary_traits< E, vector_index_norm_inf< E > >::result_type | index_norm_inf (const vector_expression< E > &e) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_scalar_binary_traits< E1, E2, vector_inner_prod< E1, E2, typename promote_traits< typename E1::value_type, typename E2::value_type >::promote_type > >::result_type | inner_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_scalar_binary_traits< E1, E2, vector_inner_prod< E1, E2, typename type_traits< typename promote_traits< typename E1::value_type, typename E2::value_type >::promote_type >::precision_type > >::result_type | prec_inner_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<template< class T1, class T2 > class F, class V , class T > | |
void | iterating_vector_assign_scalar (V &v, const T &t) |
template<template< class T1, class T2 > class F, class V , class T > | |
void | indexing_vector_assign_scalar (V &v, const T &t) |
template<template< class T1, class T2 > class F, class V , class T > | |
void | vector_assign_scalar (V &v, const T &t, dense_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class T > | |
void | vector_assign_scalar (V &v, const T &t, packed_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class T > | |
void | vector_assign_scalar (V &v, const T &t, sparse_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class T > | |
BOOST_UBLAS_INLINE void | vector_assign_scalar (V &v, const T &t) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | iterating_vector_assign (V &v, const vector_expression< E > &e) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | indexing_vector_assign (V &v, const vector_expression< E > &e) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_assign (V &v, const vector_expression< E > &e, dense_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_assign (V &v, const vector_expression< E > &e, packed_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_assign (V &v, const vector_expression< E > &e, sparse_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_assign (V &v, const vector_expression< E > &e, sparse_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
BOOST_UBLAS_INLINE void | vector_assign (V &v, const vector_expression< E > &e) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_swap (V &v, vector_expression< E > &e, dense_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_swap (V &v, vector_expression< E > &e, packed_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
void | vector_swap (V &v, vector_expression< E > &e, sparse_proxy_tag) |
template<template< class T1, class T2 > class F, class V , class E > | |
BOOST_UBLAS_INLINE void | vector_swap (V &v, vector_expression< E > &e) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE vector_matrix_binary_traits< E1, E2, scalar_multiplies< typename E1::value_type, typename E2::value_type > >::result_type | outer_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary1_traits< E, scalar_negate< typename E::value_type > >::result_type | operator- (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary1_traits< E, scalar_conj< typename E::value_type > >::result_type | conj (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary1_traits< E, scalar_real< typename E::value_type > >::result_type | real (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary1_traits< E, scalar_imag< typename E::value_type > >::result_type | imag (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary2_traits< const E, scalar_identity< typename E::value_type > >::result_type | trans (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary2_traits< E, scalar_identity< typename E::value_type > >::result_type | trans (matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_unary2_traits< E, scalar_conj< typename E::value_type > >::result_type | herm (const matrix_expression< E > &e) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_binary_traits< E1, E2, scalar_plus< typename E1::value_type, typename E2::value_type > >::result_type | operator+ (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_binary_traits< E1, E2, scalar_minus< typename E1::value_type, typename E2::value_type > >::result_type | operator- (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_binary_traits< E1, E2, scalar_multiplies< typename E1::value_type, typename E2::value_type > >::result_type | element_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_binary_traits< E1, E2, scalar_divides< typename E1::value_type, typename E2::value_type > >::result_type | element_div (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class T1 , class E2 > | |
BOOST_UBLAS_INLINE enable_if< is_convertible< T1, typename E2::value_type >, typename matrix_binary_scalar1_traits< const T1, E2, scalar_multiplies< T1, typename E2::value_type > >::result_type >::type | operator* (const T1 &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class T2 > | |
BOOST_UBLAS_INLINE enable_if< is_convertible< T2, typename E1::value_type >, typename matrix_binary_scalar2_traits< E1, const T2, scalar_multiplies< typename E1::value_type, T2 > >::result_type >::type | operator* (const matrix_expression< E1 > &e1, const T2 &e2) |
template<class E1 , class T2 > | |
BOOST_UBLAS_INLINE enable_if< is_convertible< T2, typename E1::value_type >, typename matrix_binary_scalar2_traits< E1, const T2, scalar_divides< typename E1::value_type, T2 > >::result_type >::type | operator/ (const matrix_expression< E1 > &e1, const T2 &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary1_traits< typename E1::value_type, E1, typename E2::value_type, E2 >::result_type | prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, unknown_storage_tag, row_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary1_traits< typename E1::value_type, E1, typename E2::value_type, E2 >::result_type | prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary1_traits< typename type_traits< typename E1::value_type >::precision_type, E1, typename type_traits< typename E2::value_type >::precision_type, E2 >::result_type | prec_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, unknown_storage_tag, row_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary1_traits< typename type_traits< typename E1::value_type >::precision_type, E1, typename type_traits< typename E2::value_type >::precision_type, E2 >::result_type | prec_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | prec_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V | prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V | prec_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary2_traits< typename E1::value_type, E1, typename E2::value_type, E2 >::result_type | prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, unknown_storage_tag, column_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary2_traits< typename E1::value_type, E1, typename E2::value_type, E2 >::result_type | prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary2_traits< typename type_traits< typename E1::value_type >::precision_type, E1, typename type_traits< typename E2::value_type >::precision_type, E2 >::result_type | prec_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, unknown_storage_tag, column_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_vector_binary2_traits< typename type_traits< typename E1::value_type >::precision_type, E1, typename type_traits< typename E2::value_type >::precision_type, E2 >::result_type | prec_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | prec_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V | prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V | prec_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_matrix_binary_traits< typename E1::value_type, E1, typename E2::value_type, E2 >::result_type | prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, unknown_storage_tag, unknown_orientation_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_matrix_binary_traits< typename E1::value_type, E1, typename E2::value_type, E2 >::result_type | prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_matrix_binary_traits< typename type_traits< typename E1::value_type >::precision_type, E1, typename type_traits< typename E2::value_type >::precision_type, E2 >::result_type | prec_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, unknown_storage_tag, unknown_orientation_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE matrix_matrix_binary_traits< typename type_traits< typename E1::value_type >::precision_type, E1, typename type_traits< typename E2::value_type >::precision_type, E2 >::result_type | prec_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M & | prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M & | prec_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M | prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M | prec_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_scalar_unary_traits< E, matrix_norm_1< E > >::result_type | norm_1 (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_scalar_unary_traits< E, matrix_norm_frobenius< E > >::result_type | norm_frobenius (const matrix_expression< E > &e) |
template<class E > | |
BOOST_UBLAS_INLINE matrix_scalar_unary_traits< E, matrix_norm_inf< E > >::result_type | norm_inf (const matrix_expression< E > &e) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | iterating_matrix_assign_scalar (M &m, const T &t, row_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | iterating_matrix_assign_scalar (M &m, const T &t, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | indexing_matrix_assign_scalar (M &m, const T &t, row_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | indexing_matrix_assign_scalar (M &m, const T &t, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class T , class C > | |
void | matrix_assign_scalar (M &m, const T &t, dense_proxy_tag, C) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | matrix_assign_scalar (M &m, const T &t, packed_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | matrix_assign_scalar (M &m, const T &t, packed_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | matrix_assign_scalar (M &m, const T &t, sparse_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
void | matrix_assign_scalar (M &m, const T &t, sparse_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class T > | |
BOOST_UBLAS_INLINE void | matrix_assign_scalar (M &m, const T &t) |
template<template< class T1, class T2 > class F, class M , class E > | |
void | iterating_matrix_assign (M &m, const matrix_expression< E > &e, row_major_tag) |
template<template< class T1, class T2 > class F, class M , class E > | |
void | iterating_matrix_assign (M &m, const matrix_expression< E > &e, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class E > | |
void | indexing_matrix_assign (M &m, const matrix_expression< E > &e, row_major_tag) |
template<template< class T1, class T2 > class F, class M , class E > | |
void | indexing_matrix_assign (M &m, const matrix_expression< E > &e, column_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E , class C > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, dense_proxy_tag, C) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, packed_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, packed_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, sparse_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, sparse_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, sparse_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_assign (M &m, const matrix_expression< E > &e, sparse_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class E > | |
BOOST_UBLAS_INLINE void | matrix_assign (M &m, const matrix_expression< E > &e) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
BOOST_UBLAS_INLINE void | matrix_assign (M &m, const matrix_expression< E > &e) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_swap (M &m, matrix_expression< E > &e, dense_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_swap (M &m, matrix_expression< E > &e, dense_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_swap (M &m, matrix_expression< E > &e, packed_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_swap (M &m, matrix_expression< E > &e, packed_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_swap (M &m, matrix_expression< E > &e, sparse_proxy_tag, row_major_tag) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
void | matrix_swap (M &m, matrix_expression< E > &e, sparse_proxy_tag, column_major_tag) |
template<template< class T1, class T2 > class F, class M , class E > | |
BOOST_UBLAS_INLINE void | matrix_swap (M &m, matrix_expression< E > &e) |
template<template< class T1, class T2 > class F, class R , class M , class E > | |
BOOST_UBLAS_INLINE void | matrix_swap (M &m, matrix_expression< E > &e) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_row< M > | row (M &data, typename M::size_type i) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_row< const M > | row (const M &data, typename M::size_type i) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_column< M > | column (M &data, typename M::size_type j) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_column< const M > | column (const M &data, typename M::size_type j) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_range< M > | subrange (M &data, typename M::size_type start1, typename M::size_type stop1, typename M::size_type start2, typename M::size_type stop2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_range< const M > | subrange (const M &data, typename M::size_type start1, typename M::size_type stop1, typename M::size_type start2, typename M::size_type stop2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_range< M > | project (M &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_range< const M > | project (const M &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_range< M > | project (matrix_range< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_range< M > | project (const matrix_range< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_slice< M > | subslice (M &data, typename M::size_type start1, typename M::difference_type stride1, typename M::size_type size1, typename M::size_type start2, typename M::difference_type stride2, typename M::size_type size2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_slice< const M > | subslice (const M &data, typename M::size_type start1, typename M::difference_type stride1, typename M::size_type size1, typename M::size_type start2, typename M::difference_type stride2, typename M::size_type size2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_slice< M > | project (M &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_slice< const M > | project (const M &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_slice< M > | project (matrix_slice< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_slice< M > | project (const matrix_slice< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2) |
template<class M > | |
BOOST_UBLAS_INLINE matrix_slice< M > | project (matrix_slice< M > &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2) |
template<class M > | |
BOOST_UBLAS_INLINE const matrix_slice< M > | project (const matrix_slice< M > &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2) |
template<class M , class A > | |
BOOST_UBLAS_INLINE matrix_indirect< M, indirect_array< A > > | project (M &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2) |
template<class M , class A > | |
BOOST_UBLAS_INLINE const matrix_indirect< const M, indirect_array< A > > | project (const M &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2) |
template<class M , class IA > | |
BOOST_UBLAS_INLINE matrix_indirect< M, IA > | project (matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::range_type &r1, const typename matrix_indirect< M, IA >::range_type &r2) |
template<class M , class IA > | |
BOOST_UBLAS_INLINE const matrix_indirect< M, IA > | project (const matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::range_type &r1, const typename matrix_indirect< M, IA >::range_type &r2) |
template<class M , class IA > | |
BOOST_UBLAS_INLINE matrix_indirect< M, IA > | project (matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::slice_type &s1, const typename matrix_indirect< M, IA >::slice_type &s2) |
template<class M , class IA > | |
BOOST_UBLAS_INLINE const matrix_indirect< M, IA > | project (const matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::slice_type &s1, const typename matrix_indirect< M, IA >::slice_type &s2) |
template<class M , class A > | |
BOOST_UBLAS_INLINE matrix_indirect< M, indirect_array< A > > | project (matrix_indirect< M, indirect_array< A > > &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2) |
template<class M , class A > | |
BOOST_UBLAS_INLINE const matrix_indirect< M, indirect_array< A > > | project (const matrix_indirect< M, indirect_array< A > > &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2) |
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, row_major_tag) |
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, column_major_tag) |
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true) |
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 > | |
BOOST_UBLAS_INLINE V | axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2) |
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const coordinate_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, row_major_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, column_major_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, sparse_bidirectional_iterator_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, packed_random_access_iterator_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true) |
computes v += A x or v = A x in an optimized fashion. More... | |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V | axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2) |
template<class V , class E1 , class T2 , class IA2 , class TA2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, column_major, 0, IA2, TA2 > &e2, V &v, column_major_tag) |
template<class V , class E1 , class T2 , class IA2 , class TA2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, row_major, 0, IA2, TA2 > &e2, V &v, row_major_tag) |
template<class V , class E1 , class T2 , class L2 , class IA2 , class TA2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, L2, 0, IA2, TA2 > &e2, V &v, bool init=true) |
template<class V , class E1 , class T2 , class L2 , class IA2 , class TA2 > | |
BOOST_UBLAS_INLINE V | axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, L2, 0, IA2, TA2 > &e2) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, column_major_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, row_major_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, sparse_bidirectional_iterator_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, packed_random_access_iterator_tag) |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V & | axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, bool init=true) |
computes v += AT x or v = AT x in an optimized fashion. More... | |
template<class V , class E1 , class E2 > | |
BOOST_UBLAS_INLINE V | axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class M , class E1 , class E2 , class TRI > | |
BOOST_UBLAS_INLINE M & | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, dense_proxy_tag, row_major_tag) |
template<class M , class E1 , class E2 , class TRI > | |
BOOST_UBLAS_INLINE M & | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, sparse_proxy_tag, row_major_tag) |
template<class M , class E1 , class E2 , class TRI > | |
BOOST_UBLAS_INLINE M & | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, dense_proxy_tag, column_major_tag) |
template<class M , class E1 , class E2 , class TRI > | |
BOOST_UBLAS_INLINE M & | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, sparse_proxy_tag, column_major_tag) |
template<class M , class E1 , class E2 , class TRI > | |
BOOST_UBLAS_INLINE M & | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, bool init=true) |
template<class M , class E1 , class E2 , class TRI > | |
BOOST_UBLAS_INLINE M | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, TRI) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M & | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, bool init=true) |
computes M += A X or M = A X in an optimized fashion. More... | |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M | axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M & | opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, dense_proxy_tag, row_major_tag) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M & | opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, dense_proxy_tag, column_major_tag) |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M & | opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, bool init=true) |
computes M += A X or M = A X in an optimized fashion. More... | |
template<class M , class E1 , class E2 > | |
BOOST_UBLAS_INLINE M | opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2) |
template<class V > | |
BOOST_UBLAS_INLINE vector_range< V > | subrange (V &data, typename V::size_type start, typename V::size_type stop) |
Return a vector_range on a specified vector, a start and stop index. Return a vector_range on a specified vector, a start and stop index. The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined. | |
template<class V > | |
BOOST_UBLAS_INLINE vector_range< const V > | subrange (const V &data, typename V::size_type start, typename V::size_type stop) |
Return a const vector_range on a specified vector, a start and stop index. Return a const vector_range on a specified vector, a start and stop index. The resulting const vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined. | |
template<class V > | |
BOOST_UBLAS_INLINE vector_range< V > | project (V &data, typename vector_range< V >::range_type const &r) |
Return a const vector_range on a specified vector and range Return a const vector_range on a specified vector and range . The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined. | |
template<class V > | |
BOOST_UBLAS_INLINE const vector_range< const V > | project (const V &data, typename vector_range< V >::range_type const &r) |
Return a vector_range on a specified vector and range Return a vector_range on a specified vector and range . The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined. | |
template<class V > | |
BOOST_UBLAS_INLINE vector_range< V > | project (vector_range< V > &data, const typename vector_range< V >::range_type &r) |
Return a const vector_range on a specified vector and const range Return a const vector_range on a specified vector and const range . The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined. | |
template<class V > | |
BOOST_UBLAS_INLINE const vector_range< V > | project (const vector_range< V > &data, const typename vector_range< V >::range_type &r) |
Return a vector_range on a specified vector and const range Return a vector_range on a specified vector and const range . The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined. | |
template<class V > | |
BOOST_UBLAS_INLINE vector_slice< V > | subslice (V &data, typename V::size_type start, typename V::difference_type stride, typename V::size_type size) |
template<class V > | |
BOOST_UBLAS_INLINE vector_slice< const V > | subslice (const V &data, typename V::size_type start, typename V::difference_type stride, typename V::size_type size) |
template<class V > | |
BOOST_UBLAS_INLINE vector_slice< V > | project (V &data, const typename vector_slice< V >::slice_type &s) |
template<class V > | |
BOOST_UBLAS_INLINE const vector_slice< const V > | project (const V &data, const typename vector_slice< V >::slice_type &s) |
template<class V > | |
BOOST_UBLAS_INLINE vector_slice< V > | project (vector_slice< V > &data, const typename vector_slice< V >::slice_type &s) |
template<class V > | |
BOOST_UBLAS_INLINE const vector_slice< V > | project (const vector_slice< V > &data, const typename vector_slice< V >::slice_type &s) |
template<class V > | |
BOOST_UBLAS_INLINE vector_slice< V > | project (vector_slice< V > &data, const typename vector_range< V >::range_type &r) |
template<class V > | |
BOOST_UBLAS_INLINE const vector_slice< V > | project (const vector_slice< V > &data, const typename vector_range< V >::range_type &r) |
template<class V , class A > | |
BOOST_UBLAS_INLINE vector_indirect< V, indirect_array< A > > | project (V &data, const indirect_array< A > &ia) |
template<class V , class A > | |
BOOST_UBLAS_INLINE const vector_indirect< const V, indirect_array< A > > | project (const V &data, const indirect_array< A > &ia) |
template<class V , class IA > | |
BOOST_UBLAS_INLINE vector_indirect< V, IA > | project (vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::range_type &r) |
template<class V , class IA > | |
BOOST_UBLAS_INLINE const vector_indirect< V, IA > | project (const vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::range_type &r) |
template<class V , class IA > | |
BOOST_UBLAS_INLINE vector_indirect< V, IA > | project (vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::slice_type &s) |
template<class V , class IA > | |
BOOST_UBLAS_INLINE const vector_indirect< V, IA > | project (const vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::slice_type &s) |
template<class V , class A > | |
BOOST_UBLAS_INLINE vector_indirect< V, indirect_array< A > > | project (vector_indirect< V, indirect_array< A > > &data, const indirect_array< A > &ia) |
template<class V , class A > | |
BOOST_UBLAS_INLINE const vector_indirect< V, indirect_array< A > > | project (const vector_indirect< V, indirect_array< A > > &data, const indirect_array< A > &ia) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag, dense_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag, packed_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag, unknown_storage_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag, dense_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag, packed_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag, unknown_storage_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, unit_lower_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag, dense_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag, packed_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag, unknown_storage_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag, dense_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag, packed_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag, unknown_storage_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, unit_upper_tag) |
template<class E1 , class E2 , class C > | |
BOOST_UBLAS_INLINE matrix_vector_solve_traits< E1, E2 >::result_type | solve (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, C) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, lower_tag, row_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, lower_tag, column_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, lower_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, unit_lower_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, upper_tag, row_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, upper_tag, column_major_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, upper_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, unit_upper_tag) |
template<class E1 , class E2 , class C > | |
BOOST_UBLAS_INLINE matrix_vector_solve_traits< E1, E2 >::result_type | solve (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, C) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag, dense_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag, packed_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag, unknown_storage_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, unit_lower_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag, dense_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag, packed_proxy_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag, unknown_storage_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag) |
template<class E1 , class E2 > | |
BOOST_UBLAS_INLINE void | inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, unit_upper_tag) |
template<class E1 , class E2 , class C > | |
BOOST_UBLAS_INLINE matrix_matrix_solve_traits< E1, E2 >::result_type | solve (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, C) |
template<class PM , class MV > | |
BOOST_UBLAS_INLINE void | swap_rows (const PM &pm, MV &mv, vector_tag) |
template<class PM , class MV > | |
BOOST_UBLAS_INLINE void | swap_rows (const PM &pm, MV &mv, matrix_tag) |
template<class PM , class MV > | |
BOOST_UBLAS_INLINE void | swap_rows (const PM &pm, MV &mv) |
template<class M > | |
M::size_type | lu_factorize (M &m) |
template<class M , class PM > | |
M::size_type | lu_factorize (M &m, PM &pm) |
template<class M , class PM > | |
M::size_type | axpy_lu_factorize (M &m, PM &pm) |
template<class M , class E > | |
void | lu_substitute (const M &m, vector_expression< E > &e) |
template<class M , class E > | |
void | lu_substitute (const M &m, matrix_expression< E > &e) |
template<class M , class PMT , class PMA , class MV > | |
void | lu_substitute (const M &m, const permutation_matrix< PMT, PMA > &pm, MV &mv) |
template<class E , class M > | |
void | lu_substitute (vector_expression< E > &e, const M &m) |
template<class E , class M > | |
void | lu_substitute (matrix_expression< E > &e, const M &m) |
template<class MV , class M , class PMT , class PMA > | |
void | lu_substitute (MV &mv, const M &m, const permutation_matrix< PMT, PMA > &pm) |
template<class M > | |
bool | is_symmetric (const M &m) |
template<class E , class T , class VE > | |
std::basic_ostream< E, T > & | operator<< (std::basic_ostream< E, T > &os, const vector_expression< VE > &v) |
output stream operator for vector expressions More... | |
template<class E , class T , class VT , class VA > | |
std::basic_istream< E, T > & | operator>> (std::basic_istream< E, T > &is, vector< VT, VA > &v) |
input stream operator for vectors More... | |
template<class E , class T , class ME > | |
std::basic_ostream< E, T > & | operator<< (std::basic_ostream< E, T > &os, const matrix_expression< ME > &m) |
output stream operator for matrix expressions More... | |
template<class E , class T , class MT , class MF , class MA > | |
std::basic_istream< E, T > & | operator>> (std::basic_istream< E, T > &is, matrix< MT, MF, MA > &m) |
input stream operator for matrices More... | |
template<class E , class T , class MT , class MF1 , class MF2 , class MA > | |
std::basic_istream< E, T > & | operator>> (std::basic_istream< E, T > &is, symmetric_matrix< MT, MF1, MF2, MA > &m) |
special input stream operator for symmetric matrices More... | |
main namespace of uBLAS.
Use this namespace for all operations with uBLAS. It can also be abbreviated with
A common practice is to bring this namespace into the current scope with
.
However, be warned that using the ublas namespace and the std::vector at the same time can lead to the compiler to confusion. The solution is simply to prefix each ublas vector like boost::numeric::ublas::vector<T>
. If you think it's too long to write, you can define a new namespace like namespace
ublas = boost::numeric::ublas and then just declare your vectors with ublas::vector<T>
. STL vectors will be declared as vector<T>. No need to prefix with std:
: