boost::numeric::ublas Namespace Reference

main namespace of uBLAS. More...

Namespaces
	blas_1
	Interface and implementation of BLAS level 1 This includes functions which perform vector-vector operations.
	blas_2
	Interface and implementation of BLAS level 2 This includes functions which perform matrix-vector operations.
	blas_3
	Interface and implementation of BLAS level 3 This includes functions which perform matrix-matrix operations.
	detail
	fill_policy
	hidden
	raw
	tag
	traverse_policy

Classes
class	array_adaptor
struct	assign_tag
struct	bad_argument
struct	bad_index
struct	bad_size
class	banded_adaptor
	A banded matrix adaptator: convert a any matrix into a banded matrix expression. More...
singleton	banded_matrix
	A banded matrix of values of type T. More...
struct	basic_column_major
struct	basic_full
struct	basic_lower
class	basic_range
struct	basic_row_major
class	basic_slice
struct	basic_strict_lower
struct	basic_strict_upper
struct	basic_unit_lower
struct	basic_unit_upper
struct	basic_upper
class	begin1_manip
	A begining of row manipulator. More...
class	begin2_manip
	A begining of column manipulator. More...
class	bounded_array
class	bounded_matrix
	A dense matrix of values of type T with a variable size bounded to a maximum of by . More...
class	bounded_vector
	a dense vector of values of type T, of variable size but with maximum . More...
class	c_array_view
class	c_matrix
	An array based matrix class which size is defined at type specification or object instanciation. More...
class	c_vector
	A dense vector of values of type T with the given size. The data is stored as an ordinary C++ array T data_[M]. More...
struct	column_major_tag
struct	complex_traits
class	compressed_matrix
class	compressed_matrix_view
	Present existing arrays as compressed array based sparse matrix. More...
class	compressed_vector
	Compressed array based sparse vector. More...
struct	computed_assign_tag
struct	const_iterator_type
	A const iterator for the given container type over the given dimension. More...
struct	const_iterator_type< MatrixT, tag::major >
	Specialization of const_iterator_type for matrix expressions and over the major dimension. More...
struct	const_iterator_type< MatrixT, tag::minor >
	Specialization of const_iterator_type for matrix expressions and over the minor dimension. More...
struct	const_iterator_type< VectorT, void >
	Specialization of const_iterator_type for vector expressions. More...
struct	container_traits
	Traits class to extract type information from a matrix or vector CONTAINER. More...
struct	container_view_traits
	Traits class to extract type information from a constant matrix or vector CONTAINER. More...
class	coordinate_matrix
class	coordinate_vector
	Coordimate array based sparse vector. More...
struct	dense_proxy_tag
struct	dense_random_access_iterator_tag
struct	dense_tag
class	diagonal_adaptor
	A diagonal matrix adaptator: convert a any matrix into a diagonal matrix expression. More...
singleton	diagonal_matrix
	A diagonal matrix of values of type T, which is a specialization of a banded matrix. More...
struct	divide_by_zero
	Exception raised when a division by zero occurs. More...
struct	external_logic
class	fill_policy_wrapper
	A wrapper for fill policy classes. More...
class	generalized_vector_of_vector
class	hermitian_adaptor
	A Hermitian matrix adaptator: convert a any matrix into a Hermitian matrix expression. More...
class	hermitian_matrix
	A hermitian matrix of values of type T. More...
class	identity_matrix
	An identity matrix with values of type T. More...
class	index_manipulator
	A CRTP and Barton-Nackman trick index manipulator wrapper class. More...
class	index_pair
class	index_pair_array
class	index_triple
class	index_triple_array
class	indirect_array
struct	internal_logic
	Expception raised when some interal errors occurs like computations errors, zeros values where you should not have zeros, etc... More...
struct	iterator_base_traits
struct	iterator_base_traits< dense_random_access_iterator_tag >
struct	iterator_base_traits< packed_random_access_iterator_tag >
struct	iterator_base_traits< sparse_bidirectional_iterator_tag >
struct	iterator_base_traits< std::bidirectional_iterator_tag >
struct	iterator_base_traits< std::forward_iterator_tag >
struct	iterator_base_traits< std::random_access_iterator_tag >
struct	iterator_restrict_traits
struct	iterator_restrict_traits< dense_random_access_iterator_tag, packed_random_access_iterator_tag >
struct	iterator_restrict_traits< dense_random_access_iterator_tag, sparse_bidirectional_iterator_tag >
struct	iterator_restrict_traits< packed_random_access_iterator_tag, dense_random_access_iterator_tag >
struct	iterator_restrict_traits< packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag >
struct	iterator_restrict_traits< sparse_bidirectional_iterator_tag, dense_random_access_iterator_tag >
struct	iterator_restrict_traits< sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag >
struct	iterator_type
	A iterator for the given container type over the given dimension. More...
struct	iterator_type< MatrixT, tag::major >
	Specialization of iterator_type for matrix expressions and over the major dimension. More...
struct	iterator_type< MatrixT, tag::minor >
	Specialization of iterator_type for matrix expressions and over the minor dimension. More...
struct	iterator_type< VectorT, void >
	Specialization of iterator_type for vector expressions. More...
struct	lower_tag
class	map_array
class	map_std
class	mapped_matrix
	Index map based sparse matrix of values of type T. More...
class	mapped_vector
	Index map based sparse vector. More...
class	mapped_vector_of_mapped_vector
class	matrix
	A dense matrix of values of type T. More...
class	matrix_binary
class	matrix_binary_scalar1
struct	matrix_binary_scalar1_traits
class	matrix_binary_scalar2
struct	matrix_binary_scalar2_traits
struct	matrix_binary_traits
class	matrix_column
class	matrix_column_vector
	Represents a Matrix as a vector of columns. More...
singleton	matrix_container
	Base class for Matrix container models. More...
singleton	matrix_expression
	Base class for Matrix Expression models. More...
class	matrix_expression_assigner
	An assigner object used to fill a vector using operator <<= and operator, (comma) More...
class	matrix_indirect
	A matrix referencing a non continuous submatrix of elements given another matrix of indices. More...
class	matrix_matrix_binary
struct	matrix_matrix_binary_functor
struct	matrix_matrix_binary_traits
struct	matrix_matrix_prod
struct	matrix_matrix_solve_traits
class	matrix_move_manip
	A move matrix index manipulator. More...
class	matrix_move_to_manip
	A move_to matrix manipulator. More...
struct	matrix_norm_1
struct	matrix_norm_frobenius
struct	matrix_norm_inf
class	matrix_range
class	matrix_reference
class	matrix_row
class	matrix_row_vector
	Represents a Matrix as a vector of rows. More...
struct	matrix_scalar_real_unary_functor
class	matrix_scalar_unary
struct	matrix_scalar_unary_traits
class	matrix_slice
struct	matrix_tag
struct	matrix_temporary_traits< banded_adaptor< M > >
struct	matrix_temporary_traits< const banded_adaptor< M > >
struct	matrix_temporary_traits< const hermitian_adaptor< M, TRI > >
struct	matrix_temporary_traits< const matrix_indirect< M > >
struct	matrix_temporary_traits< const matrix_range< M > >
struct	matrix_temporary_traits< const matrix_slice< M > >
struct	matrix_temporary_traits< const symmetric_adaptor< M, TRI > >
struct	matrix_temporary_traits< const triangular_adaptor< M, TRI > >
struct	matrix_temporary_traits< hermitian_adaptor< M, TRI > >
struct	matrix_temporary_traits< matrix_indirect< M > >
	Specialization of temporary_traits. More...
struct	matrix_temporary_traits< matrix_range< M > >
struct	matrix_temporary_traits< matrix_slice< M > >
struct	matrix_temporary_traits< symmetric_adaptor< M, TRI > >
struct	matrix_temporary_traits< triangular_adaptor< M, TRI > >
struct	matrix_traits
	Traits class to extract type information from a MATRIX. More...
class	matrix_unary1
struct	matrix_unary1_traits
class	matrix_unary2
struct	matrix_unary2_traits
class	matrix_vector_binary1
struct	matrix_vector_binary1_traits
class	matrix_vector_binary2
struct	matrix_vector_binary2_traits
struct	matrix_vector_binary_functor
class	matrix_vector_indirect
struct	matrix_vector_prod1
struct	matrix_vector_prod2
class	matrix_vector_range
class	matrix_vector_slice
struct	matrix_vector_solve_traits
struct	matrix_view_traits
	Traits class to extract type information from a constant MATRIX. More...
struct	matrix_view_traits< T[M][N] >
struct	mutable_container_traits
	Traits class to extract additional type information from a mutable matrix or vector CONTAINER. More...
struct	mutable_matrix_traits
	Traits class to extract additional type information from a mutable MATRIX. More...
struct	mutable_matrix_traits< T[M][N] >
struct	mutable_vector_traits
	Traits class to extract type information from a VECTOR. More...
struct	mutable_vector_traits< T[N] >
class	next_column_manip
	A next column matrix manipulator. More...
class	next_row_manip
	A next row matrix manipulator. More...
struct	non_real
struct	packed_proxy_tag
struct	packed_random_access_iterator_tag
struct	packed_tag
class	permutation_matrix
struct	promote_traits
struct	row_major_tag
struct	scalar_abs
struct	scalar_assign
struct	scalar_binary_assign_functor
struct	scalar_binary_functor
struct	scalar_binary_swap_functor
struct	scalar_conj
struct	scalar_divides
struct	scalar_divides_assign
class	scalar_expression
	Base class for Scalar Expression models. More...
struct	scalar_identity
struct	scalar_imag
class	scalar_matrix
	A matrix with all values of type T equal to the same value. More...
struct	scalar_minus
struct	scalar_minus_assign
struct	scalar_multiplies
struct	scalar_multiplies_assign
struct	scalar_negate
struct	scalar_plus
struct	scalar_plus_assign
struct	scalar_real
struct	scalar_real_unary_functor
class	scalar_reference
struct	scalar_swap
struct	scalar_tag
struct	scalar_traits
struct	scalar_unary_functor
class	scalar_value
class	scalar_vector
	A scalar (i.e. More...
struct	singular
struct	sparse_bidirectional_iterator_tag
struct	sparse_proxy_tag
struct	sparse_tag
class	static_matrix_move_manip
	A static move matrix index manipulator. More...
class	static_matrix_move_to_manip
	A static move_to matrix manipulator When member function traverse is called the referenced index will be set to the manipulators' index. More...
class	static_vector_move_manip
	A static move vector manipulator. More...
class	static_vector_move_to_manip
	A static move to vector manipulator. More...
class	storage_array
struct	storage_restrict_traits
struct	storage_restrict_traits< dense_proxy_tag, packed_proxy_tag >
struct	storage_restrict_traits< dense_proxy_tag, sparse_proxy_tag >
struct	storage_restrict_traits< dense_tag, dense_proxy_tag >
struct	storage_restrict_traits< dense_tag, packed_proxy_tag >
struct	storage_restrict_traits< dense_tag, sparse_proxy_tag >
struct	storage_restrict_traits< packed_proxy_tag, sparse_proxy_tag >
struct	storage_restrict_traits< packed_tag, dense_proxy_tag >
struct	storage_restrict_traits< packed_tag, packed_proxy_tag >
struct	storage_restrict_traits< packed_tag, sparse_proxy_tag >
struct	storage_restrict_traits< sparse_tag, dense_proxy_tag >
struct	storage_restrict_traits< sparse_tag, packed_proxy_tag >
struct	storage_restrict_traits< sparse_tag, sparse_proxy_tag >
struct	strict_lower_tag
struct	strict_upper_tag
class	symmetric_adaptor
class	symmetric_matrix
class	traverse_policy_wrapper
	A wrapper for traverse policy classes. More...
class	triangular_adaptor
class	triangular_matrix
	A triangular matrix of values of type T. More...
struct	type_traits
struct	type_traits< double >
struct	type_traits< float >
struct	type_traits< long double >
struct	type_traits< std::complex< double > >
struct	type_traits< std::complex< float > >
struct	type_traits< std::complex< long double > >
class	ublas_expression
	Base class for uBLAS statically derived expressions using the the Barton Nackman trick. More...
class	unbounded_array
struct	unit_lower_tag
struct	unit_upper_tag
class	unit_vector
	unit_vector represents a canonical unit vector unit_vector represents a canonical unit vector. More...
struct	unknown_orientation_tag
struct	unknown_storage_tag
struct	upper_tag
class	vector
	A dense vector of values of type T. More...
class	vector_binary
class	vector_binary_scalar1
struct	vector_binary_scalar1_traits
class	vector_binary_scalar2
struct	vector_binary_scalar2_traits
struct	vector_binary_traits
singleton	vector_container
	Base class for Vector container models. More...
singleton	vector_expression
	Base class for Vector Expression models. More...
class	vector_expression_assigner
	An assigner object used to fill a vector using operator <<= and operator, (comma) More...
struct	vector_index_norm_inf
class	vector_indirect
	A vector referencing a non continuous subvector of elements given another vector of indices. More...
struct	vector_inner_prod
class	vector_matrix_binary
struct	vector_matrix_binary_traits
class	vector_move_manip
	A move vector index manipulator. More...
class	vector_move_to_manip
	A move_to vector index manipulator. More...
struct	vector_norm_1
struct	vector_norm_2
struct	vector_norm_inf
class	vector_of_vector
	A dense matrix of values of type T stored as a vector of vectors. More...
class	vector_range
	A vector referencing a continuous subvector of elements of vector v containing all elements specified by range. More...
class	vector_reference
class	vector_scalar_binary
struct	vector_scalar_binary_functor
struct	vector_scalar_binary_traits
struct	vector_scalar_index_unary_functor
struct	vector_scalar_real_unary_functor
class	vector_scalar_unary
struct	vector_scalar_unary_functor
struct	vector_scalar_unary_traits
class	vector_slice
	A vector referencing a non continuous subvector of elements of vector v containing all elements specified by slice. More...
struct	vector_sum
struct	vector_tag
struct	vector_temporary_traits< banded_adaptor< M > >
struct	vector_temporary_traits< const banded_adaptor< M > >
struct	vector_temporary_traits< const hermitian_adaptor< M, TRI > >
struct	vector_temporary_traits< const matrix_column< M > >
struct	vector_temporary_traits< const matrix_indirect< M > >
struct	vector_temporary_traits< const matrix_range< M > >
struct	vector_temporary_traits< const matrix_row< M > >
struct	vector_temporary_traits< const matrix_slice< M > >
struct	vector_temporary_traits< const matrix_vector_indirect< M, IA > >
struct	vector_temporary_traits< const matrix_vector_range< M > >
struct	vector_temporary_traits< const matrix_vector_slice< M > >
struct	vector_temporary_traits< const symmetric_adaptor< M, TRI > >
struct	vector_temporary_traits< const triangular_adaptor< M, TRI > >
struct	vector_temporary_traits< const vector_indirect< V > >
struct	vector_temporary_traits< const vector_range< V > >
struct	vector_temporary_traits< const vector_slice< V > >
struct	vector_temporary_traits< hermitian_adaptor< M, TRI > >
struct	vector_temporary_traits< matrix_column< M > >
struct	vector_temporary_traits< matrix_indirect< M > >
struct	vector_temporary_traits< matrix_range< M > >
struct	vector_temporary_traits< matrix_row< M > >
struct	vector_temporary_traits< matrix_slice< M > >
struct	vector_temporary_traits< matrix_vector_indirect< M, IA > >
struct	vector_temporary_traits< matrix_vector_range< M > >
struct	vector_temporary_traits< matrix_vector_slice< M > >
struct	vector_temporary_traits< symmetric_adaptor< M, TRI > >
struct	vector_temporary_traits< triangular_adaptor< M, TRI > >
struct	vector_temporary_traits< vector_indirect< V > >
struct	vector_temporary_traits< vector_range< V > >
struct	vector_temporary_traits< vector_slice< V > >
struct	vector_traits
	Traits class to extract type information from a VECTOR. More...
class	vector_unary
struct	vector_unary_traits
struct	vector_view_traits
	Traits class to extract type information from a VECTOR. More...
struct	vector_view_traits< T[N] >
class	zero_matrix
	A matrix with all values of type T equal to zero. More...
class	zero_vector
	A zero vector of type T and a given size A zero vector of type T and a given size. More...

Typedefs
typedef traverse_policy::wrap	DEFAULT_WRAP_POLICY
typedef traverse_policy::by_row_policy < DEFAULT_WRAP_POLICY >	DEFAULT_TRAVERSE_POLICY
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

Functions
template<class E >
BOOST_UBLAS_INLINE vector_unary_traits< E, scalar_abs< typename E::value_type > >::result_type	abs (const vector_expression< E > &e)
template<class E >
BOOST_UBLAS_INLINE matrix_unary1_traits< E, scalar_abs< typename E::value_type > >::result_type	abs (const matrix_expression< E > &e)
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	operator/ (const vector_expression< E1 > &e1, const vector_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	operator/ (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 vector_binary_scalar1_traits < const T1, E2, scalar_plus < T1, typename E2::value_type > >::result_type >::type	operator+ (const T1 &e1, const vector_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_plus < T1, typename E2::value_type > >::result_type >::type	operator+ (const T1 &e1, const matrix_expression< E2 > &e2)
template<typename T >
BOOST_UBLAS_INLINE vector_move_to_manip< T >	move_to (T i)
	An object generator that returns a move_to vector index manipulator. More...
template<std::size_t I>
BOOST_UBLAS_INLINE static_vector_move_to_manip< I >	move_to ()
	An object generator that returns a static move_to vector index manipulator. More...
template<typename T >
BOOST_UBLAS_INLINE vector_move_manip< T >	move (T i)
	An object generator that returns a move vector index manipulator. More...
template<std::ptrdiff_t I>
static_vector_move_manip< I >	move ()
	An object generator that returns a static move vector index manipulator. More...
template<typename T >
BOOST_UBLAS_INLINE matrix_move_to_manip< T >	move_to (T i, T j)
	An object generator that returns a "move_to" matrix index manipulator. More...
template<std::size_t I, std::size_t J>
BOOST_UBLAS_INLINE static_matrix_move_to_manip< I, J >	move_to ()
	An object generator that returns a static move_to matrix index manipulator. More...
template<typename T >
BOOST_UBLAS_INLINE matrix_move_manip< T >	move (T i, T j)
	An object generator that returns a move matrix index manipulator. More...
template<std::ptrdiff_t I, std::ptrdiff_t J>
BOOST_UBLAS_INLINE static_matrix_move_manip< I, J >	move ()
	An object generator that returns a static "move" matrix index manipulator. More...
begin1_manip	begin1 ()
	An object generator that returns a begin1 manipulator. More...
begin2_manip	begin2 ()
	An object generator that returns a begin2 manipulator to be used to traverse a matrix. More...
next_row_manip	next_row ()
	An object generator that returns a next_row manipulator. More...
next_column_manip	next_column ()
	An object generator that returns a next_row manipulator. More...
template<class E >
BOOST_UBLAS_INLINE vector_expression_assigner < vector_expression< E > >	operator<<= (vector_expression< E > &v, const typename E::value_type &val)
	A vector_expression_assigner generator used with operator<<= for simple types. More...
template<class E1 , class E2 >
BOOST_UBLAS_INLINE vector_expression_assigner < vector_expression< E1 > >	operator<<= (vector_expression< E1 > &v, const vector_expression< E2 > &ve)
	! A vector_expression_assigner generator used with operator<<= for vector expressions More...
template<class E , typename T >
BOOST_UBLAS_INLINE vector_expression_assigner < vector_expression< E > >	operator<<= (vector_expression< E > &v, const index_manipulator< T > &nv)
	A vector_expression_assigner generator used with operator<<= for traverse manipulators. More...
template<class E , typename T >
BOOST_UBLAS_INLINE vector_expression_assigner < vector_expression< E >, T >	operator<<= (vector_expression< E > &v, fill_policy_wrapper< T >)
	A vector_expression_assigner generator used with operator<<= for choice of fill policy. More...
template<class E >
BOOST_UBLAS_INLINE matrix_expression_assigner < matrix_expression< E > >	operator<<= (matrix_expression< E > &me, const typename E::value_type &val)
	A matrix_expression_assigner generator used with operator<<= for simple types. More...
template<class E , typename T >
BOOST_UBLAS_INLINE matrix_expression_assigner < matrix_expression< E >, T >	operator<<= (matrix_expression< E > &me, fill_policy_wrapper< T >)
	A matrix_expression_assigner generator used with operator<<= for choice of fill policy. More...
template<class E , typename T >
BOOST_UBLAS_INLINE matrix_expression_assigner < matrix_expression< E > >	operator<<= (matrix_expression< E > &me, const index_manipulator< T > &ta)
	A matrix_expression_assigner generator used with operator<<= for traverse manipulators. More...
template<class E , typename T >
BOOST_UBLAS_INLINE matrix_expression_assigner < matrix_expression< E > , fill_policy::index_assign, T >	operator<<= (matrix_expression< E > &me, traverse_policy_wrapper< T >)
	A matrix_expression_assigner generator used with operator<<= for traverse manipulators. More...
template<class E1 , class E2 >
BOOST_UBLAS_INLINE matrix_expression_assigner < matrix_expression< E1 > >	operator<<= (matrix_expression< E1 > &me, const vector_expression< E2 > &ve)
	A matrix_expression_assigner generator used with operator<<= for vector expressions. More...
template<class E1 , class E2 >
BOOST_UBLAS_INLINE matrix_expression_assigner < matrix_expression< E1 > >	operator<<= (matrix_expression< E1 > &me1, const matrix_expression< E2 > &me2)
	A matrix_expression_assigner generator used with operator<<= for matrix expressions. More...
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<class L , std::size_t IB, class IA , class JA , class TA >
compressed_matrix_view< L, IB, IA, JA, TA >	make_compressed_matrix_view (typename vector_view_traits< JA >::value_type n_rows, typename vector_view_traits< JA >::value_type n_cols, typename vector_view_traits< JA >::size_type nnz, const IA &ia, const JA &ja, const TA &ta)
template<class M >
bool	is_hermitian (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...
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 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 matrix_binary_scalar2_traits < E1, const T2, scalar_divides < typename E1::value_type, T2 > >::result_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<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 Matrix >
matrix_row_vector< Matrix >	make_row_vector (matrix_expression< Matrix > &matrix)
	Convenience function to create matrix_row_vector. More...
template<class Matrix >
matrix_row_vector< Matrix const >	make_row_vector (matrix_expression< Matrix > const &matrix)
	Convenience function to create matrix_row_vector. More...
template<class Matrix >
matrix_column_vector< Matrix >	make_column_vector (matrix_expression< Matrix > &matrix)
	Convenience function to create matrix_column_vector. More...
template<class Matrix >
matrix_column_vector< Matrix const >	make_column_vector (matrix_expression< Matrix > const &matrix)
	Convenience function to create matrix_column_vector. More...
template<typename ExprT >
BOOST_UBLAS_INLINE ExprT::iterator	begin (vector_expression< ExprT > &e)
	An iterator to the first element of the given vector expression. More...
template<typename ExprT >
BOOST_UBLAS_INLINE ExprT::const_iterator	begin (vector_expression< ExprT > const &e)
	A const iterator to the first element of the given vector expression. More...
template<typename TagT , typename ExprT >
BOOST_UBLAS_INLINE iterator_type< ExprT, TagT > ::type	begin (matrix_expression< ExprT > &e)
	An iterator to the first element of the given matrix expression according to its orientation. More...
template<typename TagT , typename ExprT >
BOOST_UBLAS_INLINE const_iterator_type< ExprT, TagT >::type	begin (matrix_expression< ExprT > const &e)
	A const iterator to the first element of the given matrix expression according to its orientation. More...
template<typename IteratorT >
BOOST_UBLAS_INLINE IteratorT::dual_iterator_type	begin (IteratorT &it)
	An iterator to the first element over the dual dimension of the given iterator. More...
template<typename IteratorT >
BOOST_UBLAS_INLINE IteratorT::dual_iterator_type	begin (IteratorT const &it)
	A const iterator to the first element over the dual dimension of the given iterator. More...
template<typename ExprT >
BOOST_UBLAS_INLINE ExprT::iterator	end (vector_expression< ExprT > &e)
	An iterator to the last element of the given vector expression. More...
template<typename ExprT >
BOOST_UBLAS_INLINE ExprT::const_iterator	end (vector_expression< ExprT > const &e)
	A const iterator to the last element of the given vector expression. More...
template<typename TagT , typename ExprT >
BOOST_UBLAS_INLINE iterator_type< ExprT, TagT > ::type	end (matrix_expression< ExprT > &e)
	An iterator to the last element of the given matrix expression according to its orientation. More...
template<typename TagT , typename ExprT >
BOOST_UBLAS_INLINE const_iterator_type< ExprT, TagT >::type	end (matrix_expression< ExprT > const &e)
	A const iterator to the last element of the given matrix expression according to its orientation. More...
template<typename IteratorT >
BOOST_UBLAS_INLINE IteratorT::dual_iterator_type	end (IteratorT &it)
	An iterator to the last element over the dual dimension of the given iterator. More...
template<typename IteratorT >
BOOST_UBLAS_INLINE IteratorT::dual_iterator_type	end (IteratorT const &it)
	A const iterator to the last element over the dual dimension of the given iterator. More...
template<typename MatrixExprT >
BOOST_UBLAS_INLINE matrix_traits< MatrixExprT > ::size_type	num_columns (matrix_expression< MatrixExprT > const &me)
	Return the number of columns. More...
template<typename MatrixExprT >
BOOST_UBLAS_INLINE matrix_traits< MatrixExprT > ::size_type	num_rows (matrix_expression< MatrixExprT > const &me)
	Return the number of rows. More...
template<typename VectorExprT >
BOOST_UBLAS_INLINE typename::boost::lazy_enable_if_c < detail::has_size_type < VectorExprT >::value, detail::vector_size_type < VectorExprT >>::type	size (vector_expression< VectorExprT > const &ve)
	Return the number of columns. More...
template<std::size_t Dim, typename VectorExprT >
BOOST_UBLAS_INLINE vector_traits< VectorExprT > ::size_type	size (vector_expression< VectorExprT > const &ve)
	Return the size of the given dimension for the given vector expression. More...
template<std::size_t Dim, typename MatrixExprT >
BOOST_UBLAS_INLINE matrix_traits< MatrixExprT > ::size_type	size (matrix_expression< MatrixExprT > const &me)
	Return the size of the given dimension for the given matrix expression. More...
template<typename TagT , typename MatrixExprT >
BOOST_UBLAS_INLINE typename::boost::lazy_enable_if_c < detail::has_size_type < MatrixExprT >::value, detail::matrix_size_type < MatrixExprT >>::type	size (matrix_expression< MatrixExprT > const &me)
	Return the size of the given dimension tag for the given matrix expression. More...
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 , typename V::size_type BS, class E1 , class E2 >
BOOST_UBLAS_INLINE V	block_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2)
template<class V , typename V::size_type BS, class E1 , class E2 >
BOOST_UBLAS_INLINE V	block_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2)
template<class M , typename M::size_type BS, class E1 , class E2 >
BOOST_UBLAS_INLINE M	block_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, row_major_tag)
template<class M , typename M::size_type BS, class E1 , class E2 >
BOOST_UBLAS_INLINE M	block_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, column_major_tag)
template<class M , typename M::size_type BS, class E1 , class E2 >
BOOST_UBLAS_INLINE M	block_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M &	sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, row_major_tag)
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M &	sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, column_major_tag)
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M &	sparse_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	sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, TRI)
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M &	sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, bool init=true)
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M	sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
template<class M >
bool	is_symmetric (const M &m)
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 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 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<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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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)

Detailed Description

main namespace of uBLAS.

Use this namespace for all operations with uBLAS. It can also be abbreviated with

namespace ublas = boost::numeric::ublas; 

A common practice is to bring this namespace into the current scope with

using namespace boost::numeric::ublas; 

.

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::

Typedef Documentation

typedef basic_column_major boost::numeric::ublas::column_major

typedef traverse_policy::by_row_policy<DEFAULT_WRAP_POLICY> boost::numeric::ublas::DEFAULT_TRAVERSE_POLICY

typedef traverse_policy::wrap boost::numeric::ublas::DEFAULT_WRAP_POLICY

typedef basic_full boost::numeric::ublas::full

typedef basic_lower boost::numeric::ublas::lower

typedef basic_range boost::numeric::ublas::range

typedef basic_row_major boost::numeric::ublas::row_major

typedef basic_slice boost::numeric::ublas::slice

typedef basic_strict_lower boost::numeric::ublas::strict_lower

typedef basic_strict_upper boost::numeric::ublas::strict_upper

typedef basic_unit_lower boost::numeric::ublas::unit_lower

typedef basic_unit_upper boost::numeric::ublas::unit_upper

typedef basic_upper boost::numeric::ublas::upper

Function Documentation

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_abs<typename E::value_type> >::result_type boost::numeric::ublas::abs

(

const vector_expression< E > &

e

)

Referenced by boost::numeric::ublas::scalar_abs< T >::apply(), and boost::numeric::ublas::complex_traits< std::complex< long double > >::type_abs().

template<class E >

BOOST_UBLAS_INLINE matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::result_type boost::numeric::ublas::abs

(

const matrix_expression< E > &

e

)

Referenced by boost::numeric::ublas::scalar_abs< T >::apply().

template<class M , class PM >

M::size_type boost::numeric::ublas::axpy_lu_factorize	(	M &	m,
		PM &	pm
	)

References boost::numeric::ublas::vector_range< V >::assign(), BOOST_UBLAS_CHECK, column(), boost::multiprecision::backends::i, index_norm_inf(), inplace_solve(), boost::polygon::lr(), boost::accumulators::extract::min, boost::locale::period::pm(), prod(), project(), row(), size(), solve(), boost::swap, swap_rows(), and boost::polygon::ur().

template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const compressed_matrix< T1, L1, 0, IA1, TA1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		row_major_tag
	)

References begin(), end(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::filled1(), boost::multiprecision::backends::i, boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index1_data(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index2_data(), boost::flyweights::t, and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::value_data().

Referenced by axpy_prod().

template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const compressed_matrix< T1, L1, 0, IA1, TA1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		column_major_tag
	)

References begin(), end(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::filled1(), boost::multiprecision::backends::i, boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index1_data(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index2_data(), and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::value_data().

template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const compressed_matrix< T1, L1, 0, IA1, TA1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		bool	init = true
	)

References axpy_prod(), BOOST_UBLAS_CHECK, boost::math::tools::epsilon, boost::unit_test::framework::init(), norm_1(), prod(), and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::size1().

template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::axpy_prod	(	const compressed_matrix< T1, L1, 0, IA1, TA1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References axpy_prod(), and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::size1().

template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const coordinate_matrix< T1, L1, 0, IA1, TA1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		bool	init = true
	)

References boost::multiprecision::backends::i, boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::index1_data(), boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::index2_data(), boost::unit_test::framework::init(), boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::nnz(), boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::size1(), boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::size2(), and boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::value_data().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		packed_random_access_iterator_tag	,
		row_major_tag
	)

References begin(), begin1(), and end().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		packed_random_access_iterator_tag	,
		column_major_tag
	)

References begin(), begin2(), and end().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		sparse_bidirectional_iterator_tag
	)

References begin(), column(), end(), and boost::it.

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v,
		packed_random_access_iterator_tag
	)

References axpy_prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::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.

Parameters

e1	the matrix expression A
e2	the vector expression x
v	the result vector v
init	a boolean parameter

axpy_prod(A, x, v, init) implements the well known axpy-product. Setting init to true is equivalent to call v.clear() before axpy_prod. Currently init defaults to true, but this may change in the future.

Up to now there are some specialisation for compressed matrices that give a large speed up compared to prod.

References axpy_prod(), BOOST_UBLAS_CHECK, boost::math::tools::epsilon, boost::unit_test::framework::init(), norm_1(), and prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References axpy_prod().

template<class V , class E1 , class T2 , class IA2 , class TA2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const compressed_matrix< T2, column_major, 0, IA2, TA2 > &	e2,
		V &	v,
		column_major_tag
	)

References begin(), end(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::filled1(), boost::multiprecision::backends::i, boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index1_data(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index2_data(), boost::flyweights::t, and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::value_data().

template<class V , class E1 , class T2 , class IA2 , class TA2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const compressed_matrix< T2, row_major, 0, IA2, TA2 > &	e2,
		V &	v,
		row_major_tag
	)

References begin(), end(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::filled1(), boost::multiprecision::backends::i, boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index1_data(), boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::index2_data(), and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::value_data().

template<class V , class E1 , class T2 , class L2 , class IA2 , class TA2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const compressed_matrix< T2, L2, 0, IA2, TA2 > &	e2,
		V &	v,
		bool	init = true
	)

References axpy_prod(), BOOST_UBLAS_CHECK, boost::math::tools::epsilon, boost::unit_test::framework::init(), norm_1(), prod(), and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::size2().

template<class V , class E1 , class T2 , class L2 , class IA2 , class TA2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const compressed_matrix< T2, L2, 0, IA2, TA2 > &	e2
	)

References axpy_prod(), and boost::numeric::ublas::compressed_matrix< T, L, IB, IA, TA >::size2().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		V &	v,
		packed_random_access_iterator_tag	,
		column_major_tag
	)

References begin(), begin2(), and end().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		V &	v,
		packed_random_access_iterator_tag	,
		row_major_tag
	)

References begin(), begin1(), and end().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		V &	v,
		sparse_bidirectional_iterator_tag
	)

References begin(), end(), boost::it, and row().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		V &	v,
		packed_random_access_iterator_tag
	)

References axpy_prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::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.

Parameters

e1	the vector expression x
e2	the matrix expression A
v	the result vector v
init	a boolean parameter

axpy_prod(x, A, v, init) implements the well known axpy-product. Setting init to true is equivalent to call v.clear() before axpy_prod. Currently init defaults to true, but this may change in the future.

Up to now there are some specialisation for compressed matrices that give a large speed up compared to prod.

References axpy_prod(), BOOST_UBLAS_CHECK, boost::math::tools::epsilon, boost::unit_test::framework::init(), norm_1(), and prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::axpy_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References axpy_prod().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		dense_proxy_tag	,
		row_major_tag
	)

References BOOST_UBLAS_CHECK, boost::math::tools::epsilon, boost::multiprecision::backends::i, norm_1(), prod(), and row().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		sparse_proxy_tag	,
		row_major_tag
	)

References begin(), begin1(), BOOST_UBLAS_CHECK, end(), boost::math::tools::epsilon, norm_1(), boost::spirit::x3::unicode::other, and prod().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		dense_proxy_tag	,
		column_major_tag
	)

References BOOST_UBLAS_CHECK, column(), boost::math::tools::epsilon, boost::multiprecision::backends::i, norm_1(), and prod().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		sparse_proxy_tag	,
		column_major_tag
	)

References begin(), begin2(), BOOST_UBLAS_CHECK, end(), boost::math::tools::epsilon, norm_1(), boost::spirit::x3::unicode::other, and prod().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		bool	init = true
	)

References axpy_prod(), and boost::unit_test::framework::init().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		TRI
	)

References axpy_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::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.

Parameters

e1	the matrix expression A
e2	the matrix expression X
m	the result matrix M
init	a boolean parameter

axpy_prod(A, X, M, init) implements the well known axpy-product. Setting init to true is equivalent to call M.clear() before axpy_prod. Currently init defaults to true, but this may change in the future.

Up to now there are no specialisations.

References axpy_prod(), and boost::unit_test::framework::init().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::axpy_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References axpy_prod().

template<typename ExprT >

BOOST_UBLAS_INLINE ExprT::iterator boost::numeric::ublas::begin

(

vector_expression< ExprT > &

e

)

An iterator to the first element of the given vector expression.

Template Parameters

ExprT

A model of VectorExpression type.

Parameters

e	A vector expression.

Returns

An iterator to the first element of the given vector expression.

Referenced by axpy_prod(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator1::cbegin(), boost::numeric::ublas::matrix< T, L, A >::const_iterator1::cbegin(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator2::cbegin(), boost::numeric::ublas::matrix< T, L, A >::const_iterator2::cbegin(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator1::cbegin(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator2::cbegin(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator1::cbegin(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator2::cbegin(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator1::cbegin(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator2::cbegin(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator1::cbegin(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator2::cbegin(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator1::cbegin(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator2::cbegin(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator1::cbegin(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator2::cbegin(), boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::clear(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::clear(), boost::numeric::ublas::matrix< T, L, bounded_array< T, M *N > >::clear(), boost::numeric::ublas::banded_matrix< T, L, A >::clear(), boost::numeric::ublas::hermitian_matrix< T, TRI, L, A >::clear(), boost::numeric::ublas::matrix< T, L, bounded_array< T, M *N > >::find1(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::find1(), boost::numeric::ublas::vector_of_vector< T, L, A >::find1(), boost::numeric::ublas::matrix< T, L, bounded_array< T, M *N > >::find2(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::find2(), boost::numeric::ublas::vector_of_vector< T, L, A >::find2(), boost::numeric::ublas::detail::lower_bound(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::nnz(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::nnz_capacity(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator1::rend(), boost::numeric::ublas::matrix< T, L, A >::const_iterator1::rend(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::iterator1::rend(), boost::numeric::ublas::matrix< T, L, A >::iterator1::rend(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator2::rend(), boost::numeric::ublas::matrix< T, L, A >::const_iterator2::rend(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::iterator2::rend(), boost::numeric::ublas::matrix< T, L, A >::iterator2::rend(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator1::rend(), boost::numeric::ublas::triangular_adaptor< M, TRI >::iterator1::rend(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator2::rend(), boost::numeric::ublas::triangular_adaptor< M, TRI >::iterator2::rend(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator1::rend(), boost::numeric::ublas::vector_of_vector< T, L, A >::iterator1::rend(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator2::rend(), boost::numeric::ublas::vector_of_vector< T, L, A >::iterator2::rend(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator1::rend(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator2::rend(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator1::rend(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator2::rend(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator1::rend(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator2::rend(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator1::rend(), boost::numeric::ublas::c_matrix< T, N, M >::iterator1::rend(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator2::rend(), boost::numeric::ublas::c_matrix< T, N, M >::iterator2::rend(), boost::numeric::ublas::generalized_vector_of_vector< T, L, A >::sort(), sparse_prod(), and boost::numeric::ublas::detail::upper_bound().

template<typename ExprT >

BOOST_UBLAS_INLINE ExprT::const_iterator boost::numeric::ublas::begin

(

vector_expression< ExprT > const &

e

)

A const iterator to the first element of the given vector expression.

Template Parameters

ExprT

A model of VectorExpression type.

Parameters

e	A vector expression.

Returns

A const iterator to the first element of the given vector expression.

template<typename TagT , typename ExprT >

BOOST_UBLAS_INLINE iterator_type<ExprT,TagT>::type boost::numeric::ublas::begin

(

matrix_expression< ExprT > &

e

)

An iterator to the first element of the given matrix expression according to its orientation.

Template Parameters

DimTagT	A dimension tag type (e.g., tag::major).
ExprT	A model of MatrixExpression type.

Parameters

e	A matrix expression.

Returns

An iterator to the first element of the given matrix expression according to its orientation.

template<typename TagT , typename ExprT >

BOOST_UBLAS_INLINE const_iterator_type<ExprT,TagT>::type boost::numeric::ublas::begin

(

matrix_expression< ExprT > const &

e

)

A const iterator to the first element of the given matrix expression according to its orientation.

Template Parameters

TagT	A dimension tag type (e.g., tag::major).
ExprT	A model of MatrixExpression type.

Parameters

e	A matrix expression.

Returns

A const iterator to the first element of the given matrix expression according to its orientation.

template<typename IteratorT >

BOOST_UBLAS_INLINE IteratorT::dual_iterator_type boost::numeric::ublas::begin

(

IteratorT &

it

)

An iterator to the first element over the dual dimension of the given iterator.

Template Parameters

IteratorT

A model of Iterator type.

Parameters

it	An iterator.

Returns

An iterator to the first element over the dual dimension of the given iterator.

template<typename IteratorT >

BOOST_UBLAS_INLINE IteratorT::dual_iterator_type boost::numeric::ublas::begin

(

IteratorT const &

it

)

A const iterator to the first element over the dual dimension of the given iterator.

Template Parameters

IteratorT

A model of Iterator type.

Parameters

it	An iterator.

Returns

A const iterator to the first element over the dual dimension of the given iterator.

begin1_manip boost::numeric::ublas::begin1 ( )

inline

An object generator that returns a begin1 manipulator.

The resulted manipulator will traverse the index to the begining of the current column when its' manip member function is called.

Returns

A begin1 matrix index manipulator

Example usage:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, next_row(),
     3, 4, begin1(), 1;

will result in:

1 2 1
3 4 0
0 0 0

See also

begin2()

Referenced by axpy_prod(), and sparse_prod().

begin2_manip boost::numeric::ublas::begin2 ( )

inline

An object generator that returns a begin2 manipulator to be used to traverse a matrix.

The resulted manipulator will traverse the index to the begining of the current row when its' manip member function is called.

Returns

A begin2 matrix manipulator

Example:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, move<1,0>(),
     3, begin2(), 1;

will result in:

1 2 0
1 0 3
0 0 0

See also

begin1() begin2_manip

Referenced by axpy_prod(), boost::wave::impl::pp_iterator_functor< ContextT >::on_elif(), boost::wave::impl::pp_iterator_functor< ContextT >::on_error(), boost::wave::impl::pp_iterator_functor< ContextT >::on_if(), boost::wave::impl::pp_iterator_functor< ContextT >::on_include(), boost::wave::impl::pp_iterator_functor< ContextT >::on_line(), and sparse_prod().

template<class V , typename V::size_type BS, class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::block_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References boost::numeric::ublas::vector< T, A >::assign(), BOOST_UBLAS_CHECK, BOOST_UBLAS_SAME, boost::math::tools::epsilon, boost::accumulators::extract::min, norm_1(), boost::numeric::ublas::vector< T, A >::plus_assign(), prod(), project(), and size().

template<class V , typename V::size_type BS, class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::block_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References boost::numeric::ublas::vector< T, A >::assign(), BOOST_UBLAS_CHECK, BOOST_UBLAS_SAME, boost::math::tools::epsilon, boost::accumulators::extract::min, norm_1(), boost::numeric::ublas::vector< T, A >::plus_assign(), prod(), project(), and size().

template<class M , typename M::size_type BS, class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::block_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		row_major_tag
	)

References boost::numeric::ublas::matrix< T, L, A >::assign(), BOOST_UBLAS_CHECK, BOOST_UBLAS_SAME, boost::math::tools::epsilon, boost::accumulators::extract::min, norm_1(), boost::numeric::ublas::matrix< T, L, A >::plus_assign(), prod(), project(), and boost::program_options::value().

template<class M , typename M::size_type BS, class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::block_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		column_major_tag
	)

References boost::numeric::ublas::matrix< T, L, A >::assign(), BOOST_UBLAS_CHECK, BOOST_UBLAS_SAME, boost::math::tools::epsilon, boost::accumulators::extract::min, norm_1(), boost::numeric::ublas::matrix< T, L, A >::plus_assign(), prod(), project(), and boost::program_options::value().

template<class M , typename M::size_type BS, class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::block_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

template<class M >

BOOST_UBLAS_INLINE matrix_column<M> boost::numeric::ublas::column	(	M &	data,
		typename M::size_type	j
	)

References boost::proto::envns_::data.

Referenced by boost::numeric::ublas::matrix_vector_prod2< M1, M2, TV >::apply(), boost::numeric::ublas::matrix_matrix_prod< M1, M2, TV >::apply(), axpy_lu_factorize(), axpy_prod(), boost::wave::cpp_exception::column_no(), boost::wave::cpplexer::cpplexer_exception::column_no(), boost::wave::impl::pp_iterator_functor< ContextT >::emit_line_directive(), boost::spirit::get_column(), lu_factorize(), opb_prod(), and boost::grid_force_pairs< Topology, PositionMap >::operator()().

template<class M >

BOOST_UBLAS_INLINE const matrix_column<const M> boost::numeric::ublas::column	(	const M &	data,
		typename M::size_type	j
	)

References boost::proto::envns_::data.

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_conj<typename E::value_type> >::result_type boost::numeric::ublas::conj

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_unary1_traits<E, scalar_conj<typename E::value_type> >::result_type boost::numeric::ublas::conj

(

const matrix_expression< E > &

e

)

Referenced by boost::numeric::ublas::blas_2::hr(), boost::numeric::ublas::blas_2::hr2(), and is_hermitian().

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 boost::numeric::ublas::element_div	(	const vector_expression< E1 > &	e1,
		const vector_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 boost::numeric::ublas::element_div	(	const matrix_expression< E1 > &	e1,
		const matrix_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 boost::numeric::ublas::element_prod	(	const vector_expression< E1 > &	e1,
		const vector_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 boost::numeric::ublas::element_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

template<typename ExprT >

BOOST_UBLAS_INLINE ExprT::iterator boost::numeric::ublas::end

(

vector_expression< ExprT > &

e

)

An iterator to the last element of the given vector expression.

Template Parameters

ExprT

A model of VectorExpression type.

Parameters

e	A vector expression.

Returns

An iterator to the last element of the given vector expression.

Referenced by axpy_prod(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator1::cend(), boost::numeric::ublas::matrix< T, L, A >::const_iterator1::cend(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator2::cend(), boost::numeric::ublas::matrix< T, L, A >::const_iterator2::cend(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator1::cend(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator2::cend(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator1::cend(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator2::cend(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator1::cend(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator2::cend(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator1::cend(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator2::cend(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator1::cend(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator2::cend(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator1::cend(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator2::cend(), boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::clear(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::clear(), boost::numeric::ublas::matrix< T, L, bounded_array< T, M *N > >::clear(), boost::numeric::ublas::banded_matrix< T, L, A >::clear(), boost::numeric::ublas::hermitian_matrix< T, TRI, L, A >::clear(), boost::numeric::ublas::generalized_vector_of_vector< T, L, A >::erase_element(), boost::numeric::ublas::mapped_matrix< T, L, A >::erase_element(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::erase_element(), boost::numeric::ublas::generalized_vector_of_vector< T, L, A >::find1(), boost::numeric::ublas::mapped_matrix< T, L, A >::find1(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::find1(), boost::numeric::ublas::generalized_vector_of_vector< T, L, A >::find2(), boost::numeric::ublas::mapped_matrix< T, L, A >::find2(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::find2(), boost::numeric::ublas::mapped_matrix< T, L, A >::find_element(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::find_element(), boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::inplace_merge(), boost::numeric::ublas::detail::lower_bound(), boost::numeric::ublas::coordinate_matrix< T, L, IB, IA, TA >::lower_bound(), boost::numeric::ublas::mapped_matrix< T, L, A >::operator()(), boost::numeric::ublas::mapped_vector_of_mapped_vector< T, L, A >::operator()(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator1::rbegin(), boost::numeric::ublas::matrix< T, L, A >::const_iterator1::rbegin(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::iterator1::rbegin(), boost::numeric::ublas::matrix< T, L, A >::iterator1::rbegin(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::const_iterator2::rbegin(), boost::numeric::ublas::matrix< T, L, A >::const_iterator2::rbegin(), boost::numeric::ublas::triangular_matrix< T, TRI, L, A >::iterator2::rbegin(), boost::numeric::ublas::matrix< T, L, A >::iterator2::rbegin(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator1::rbegin(), boost::numeric::ublas::triangular_adaptor< M, TRI >::iterator1::rbegin(), boost::numeric::ublas::triangular_adaptor< M, TRI >::const_iterator2::rbegin(), boost::numeric::ublas::triangular_adaptor< M, TRI >::iterator2::rbegin(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator1::rbegin(), boost::numeric::ublas::vector_of_vector< T, L, A >::iterator1::rbegin(), boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator2::rbegin(), boost::numeric::ublas::vector_of_vector< T, L, A >::iterator2::rbegin(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator1::rbegin(), boost::numeric::ublas::zero_matrix< T, ALLOC >::const_iterator2::rbegin(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator1::rbegin(), boost::numeric::ublas::identity_matrix< T, ALLOC >::const_iterator2::rbegin(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator1::rbegin(), boost::numeric::ublas::scalar_matrix< T, ALLOC >::const_iterator2::rbegin(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator1::rbegin(), boost::numeric::ublas::c_matrix< T, N, M >::iterator1::rbegin(), boost::numeric::ublas::c_matrix< T, N, M >::const_iterator2::rbegin(), boost::numeric::ublas::c_matrix< T, N, M >::iterator2::rbegin(), boost::numeric::ublas::generalized_vector_of_vector< T, L, A >::sort(), sparse_prod(), and boost::numeric::ublas::detail::upper_bound().

template<typename ExprT >

BOOST_UBLAS_INLINE ExprT::const_iterator boost::numeric::ublas::end

(

vector_expression< ExprT > const &

e

)

A const iterator to the last element of the given vector expression.

Template Parameters

ExprT

A model of VectorExpression type.

Parameters

e	A vector expression.

Returns

A const iterator to the last element of the given vector expression.

template<typename TagT , typename ExprT >

BOOST_UBLAS_INLINE iterator_type<ExprT,TagT>::type boost::numeric::ublas::end

(

matrix_expression< ExprT > &

e

)

An iterator to the last element of the given matrix expression according to its orientation.

Template Parameters

DimTagT	A dimension tag type (e.g., tag::major).
ExprT	A model of MatrixExpression type.

Parameters

e	A matrix expression.

Returns

An iterator to the last element of the given matrix expression according to its orientation.

template<typename TagT , typename ExprT >

BOOST_UBLAS_INLINE const_iterator_type<ExprT,TagT>::type boost::numeric::ublas::end

(

matrix_expression< ExprT > const &

e

)

A const iterator to the last element of the given matrix expression according to its orientation.

Template Parameters

TagT	A dimension tag type (e.g., tag::major).
ExprT	A model of MatrixExpression type.

Parameters

e	A matrix expression.

Returns

A const iterator to the last element of the given matrix expression according to its orientation.

template<typename IteratorT >

BOOST_UBLAS_INLINE IteratorT::dual_iterator_type boost::numeric::ublas::end

(

IteratorT &

it

)

An iterator to the last element over the dual dimension of the given iterator.

Template Parameters

IteratorT

A model of Iterator type.

Parameters

it	An iterator.

Returns

An iterator to the last element over the dual dimension of the given iterator.

template<typename IteratorT >

BOOST_UBLAS_INLINE IteratorT::dual_iterator_type boost::numeric::ublas::end

(

IteratorT const &

it

)

A const iterator to the last element over the dual dimension of the given iterator.

Template Parameters

IteratorT

A model of Iterator type.

Parameters

it	An iterator.

Returns

A const iterator to the last element over the dual dimension of the given iterator.

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_conj<typename E::value_type> >::result_type boost::numeric::ublas::herm

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_unary2_traits<E, scalar_conj<typename E::value_type> >::result_type boost::numeric::ublas::herm

(

const matrix_expression< E > &

e

)

Referenced by boost::numeric::ublas::blas_3::hr2k(), and boost::numeric::ublas::blas_3::hrk().

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_imag<typename E::value_type> >::result_type boost::numeric::ublas::imag

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_unary1_traits<E, scalar_imag<typename E::value_type> >::result_type boost::numeric::ublas::imag

(

const matrix_expression< E > &

e

)

template<class I >

BOOST_UBLAS_INLINE void boost::numeric::ublas::increment	(	I &	it,
		const I &	it_end,
		typename I::difference_type	compare,
		packed_random_access_iterator_tag
	)

References boost::accumulators::extract::min.

Referenced by boost::numeric::ublas::vector_inner_prod< V1, V2, TV >::apply(), boost::numeric::ublas::matrix_vector_prod1< M1, M2, TV >::apply(), boost::numeric::ublas::matrix_vector_prod2< M1, M2, TV >::apply(), boost::numeric::ublas::matrix_matrix_prod< M1, M2, TV >::apply(), boost::random::inversive_congruential_engine< IntType, a, b, p >::BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(), boost::random::linear_congruential_engine< IntType, a, c, m >::BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(), boost::heap::binomial_heap< T, A0, A1, A2, A3 >::emplace(), boost::heap::fibonacci_heap< T, A0, A1, A2, A3, A4 >::emplace(), boost::heap::pairing_heap< T, A0, A1, A2, A3, A4 >::emplace(), boost::circular_buffer< Sample >::erase(), increment(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::insert(), boost::sp_adl_block::intrusive_ptr_add_ref(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::modify_rollback_(), boost::spirit::multi_pass< T, iterator_policies::default_policy< iterator_policies::first_owner, iterator_policies::no_check, iterator_policies::input_iterator, iterator_policies::fixed_size_queue< N > > >::operator++(), boost::spirit::multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy >::operator++(), boost::circular_buffer< Sample >::pop_front(), boost::heap::binomial_heap< T, A0, A1, A2, A3 >::push(), boost::heap::fibonacci_heap< T, A0, A1, A2, A3, A4 >::push(), boost::heap::pairing_heap< T, A0, A1, A2, A3, A4 >::push(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::replace_(), and boost::circular_buffer< Sample >::rerase().

template<class I >

BOOST_UBLAS_INLINE void boost::numeric::ublas::increment	(	I &	it,
		const I &	,
		typename I::difference_type	,
		sparse_bidirectional_iterator_tag
	)

References boost::it.

template<class I >

BOOST_UBLAS_INLINE void boost::numeric::ublas::increment	(	I &	it,
		const I &	it_end,
		typename I::difference_type	compare
	)

References increment().

template<class I >

BOOST_UBLAS_INLINE void boost::numeric::ublas::increment	(	I &	it,
		const I &	it_end
	)

References BOOST_UBLAS_CHECK.

template<class E >

BOOST_UBLAS_INLINE vector_scalar_unary_traits<E, vector_index_norm_inf<E> >::result_type boost::numeric::ublas::index_norm_inf

(

const vector_expression< E > &

e

)

Referenced by axpy_lu_factorize(), and lu_factorize().

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 boost::numeric::ublas::inner_prod	(	const vector_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

Referenced by boost::numeric::ublas::blas_1::dot().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		column_major_tag	,
		dense_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

Referenced by axpy_lu_factorize(), inplace_solve(), lu_substitute(), and solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		column_major_tag	,
		packed_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		column_major_tag	,
		unknown_storage_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		row_major_tag	,
		dense_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		row_major_tag	,
		packed_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		row_major_tag	,
		unknown_storage_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		column_major_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag	,
		row_major_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		lower_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		unit_lower_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		column_major_tag	,
		dense_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		column_major_tag	,
		packed_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		column_major_tag	,
		unknown_storage_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		row_major_tag	,
		dense_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		row_major_tag	,
		packed_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		row_major_tag	,
		unknown_storage_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), size(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		column_major_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag	,
		row_major_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		upper_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		vector_expression< E2 > &	e2,
		unit_upper_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		lower_tag	,
		row_major_tag
	)

References inplace_solve(), and trans().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		lower_tag	,
		column_major_tag
	)

References inplace_solve(), and trans().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		lower_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		unit_lower_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		upper_tag	,
		row_major_tag
	)

References inplace_solve(), and trans().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		upper_tag	,
		column_major_tag
	)

References inplace_solve(), and trans().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		upper_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		unit_upper_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		lower_tag	,
		dense_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		lower_tag	,
		packed_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		lower_tag	,
		unknown_storage_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		lower_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		unit_lower_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		upper_tag	,
		dense_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		upper_tag	,
		packed_proxy_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		upper_tag	,
		unknown_storage_tag
	)

References BOOST_UBLAS_CHECK, boost::n, boost::numeric::ublas::singular::raise(), and boost::flyweights::t.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		upper_tag
	)

References inplace_solve().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE void boost::numeric::ublas::inplace_solve	(	const matrix_expression< E1 > &	e1,
		matrix_expression< E2 > &	e2,
		unit_upper_tag
	)

References inplace_solve().

template<class M >

bool boost::numeric::ublas::is_hermitian

(

const M &

m

)

References BOOST_UBLAS_SAME, conj(), boost::multiprecision::backends::i, and size().

template<class M >

bool boost::numeric::ublas::is_symmetric

(

const M &

m

)

References BOOST_UBLAS_SAME, boost::multiprecision::backends::i, and size().

template<class M >

M::size_type boost::numeric::ublas::lu_factorize

(

M &

m

)

References BOOST_UBLAS_CHECK, column(), boost::multiprecision::backends::i, boost::accumulators::extract::min, outer_prod(), prod(), project(), row(), and size().

Referenced by boost::numeric::odeint::rosenbrock4< Value, Coefficients, Resizer >::do_step().

template<class M , class PM >

M::size_type boost::numeric::ublas::lu_factorize	(	M &	m,
		PM &	pm
	)

References BOOST_UBLAS_CHECK, column(), boost::multiprecision::backends::i, index_norm_inf(), boost::accumulators::extract::min, outer_prod(), boost::locale::period::pm(), prod(), project(), row(), size(), and swap_rows().

template<class M , class E >

void boost::numeric::ublas::lu_substitute	(	const M &	m,
		vector_expression< E > &	e
	)

References BOOST_UBLAS_CHECK, inplace_solve(), and prod().

Referenced by boost::numeric::odeint::rosenbrock4< Value, Coefficients, Resizer >::do_step(), boost::geometry::strategy::transform::inverse_transformer< CalculationType, Dimension1, Dimension2 >::inverse_transformer(), and lu_substitute().

template<class M , class E >

void boost::numeric::ublas::lu_substitute	(	const M &	m,
		matrix_expression< E > &	e
	)

References BOOST_UBLAS_CHECK, inplace_solve(), and prod().

template<class M , class PMT , class PMA , class MV >

void boost::numeric::ublas::lu_substitute	(	const M &	m,
		const permutation_matrix< PMT, PMA > &	pm,
		MV &	mv
	)

References lu_substitute(), and swap_rows().

template<class E , class M >

void boost::numeric::ublas::lu_substitute	(	vector_expression< E > &	e,
		const M &	m
	)

References BOOST_UBLAS_CHECK, inplace_solve(), and prod().

template<class E , class M >

void boost::numeric::ublas::lu_substitute	(	matrix_expression< E > &	e,
		const M &	m
	)

References BOOST_UBLAS_CHECK, inplace_solve(), and prod().

template<class MV , class M , class PMT , class PMA >

void boost::numeric::ublas::lu_substitute	(	MV &	mv,
		const M &	m,
		const permutation_matrix< PMT, PMA > &	pm
	)

References lu_substitute(), and swap_rows().

template<class Matrix >

matrix_column_vector<Matrix> boost::numeric::ublas::make_column_vector

(

matrix_expression< Matrix > &

matrix

)

Convenience function to create matrix_column_vector.

Function to create matrix_column_vector objects.

Parameters

matrix

the matrix_expression that generates the matrix that matrix_column_vector is referring.

Returns

Created matrix_column_vector object.

Template Parameters

Matrix

the type of matrix that matrix_column_vector is referring.

template<class Matrix >

matrix_column_vector<Matrix const> boost::numeric::ublas::make_column_vector

(

matrix_expression< Matrix > const &

matrix

)

Convenience function to create matrix_column_vector.

Function to create matrix_column_vector objects.

Parameters

matrix

the matrix_expression that generates the matrix that matrix_column_vector is referring.

Returns

Created matrix_column_vector object.

Template Parameters

Matrix

the type of matrix that matrix_column_vector is referring.

template<class L , std::size_t IB, class IA , class JA , class TA >

compressed_matrix_view<L,IB,IA,JA,TA> boost::numeric::ublas::make_compressed_matrix_view	(	typename vector_view_traits< JA >::value_type	n_rows,
		typename vector_view_traits< JA >::value_type	n_cols,
		typename vector_view_traits< JA >::size_type	nnz,
		const IA &	ia,
		const JA &	ja,
		const TA &	ta
	)

template<class Matrix >

matrix_row_vector<Matrix> boost::numeric::ublas::make_row_vector

(

matrix_expression< Matrix > &

matrix

)

Convenience function to create matrix_row_vector.

Function to create matrix_row_vector objects.

Parameters

matrix

the matrix_expression that generates the matrix that matrix_row_vector is referring.

Returns

Created matrix_row_vector object.

Template Parameters

Matrix

the type of matrix that matrix_row_vector is referring.

template<class Matrix >

matrix_row_vector<Matrix const> boost::numeric::ublas::make_row_vector

(

matrix_expression< Matrix > const &

matrix

)

Convenience function to create matrix_row_vector.

Function to create matrix_row_vector objects.

Parameters

matrix

the matrix_expression that generates the matrix that matrix_row_vector is referring.

Returns

Created matrix_row_vector object.

Template Parameters

Matrix

the type of matrix that matrix_row_vector is referring.

template<typename T >

BOOST_UBLAS_INLINE vector_move_manip<T> boost::numeric::ublas::move

(

T

i

)

An object generator that returns a move vector index manipulator.

Template Parameters

T

Size type

Parameters

i	The number of elements the manipulator will traverse the index when manip member function is called. Negative values can be used.

Returns

A move vector manipulator

Example usage:

vector<double> a(6, 0);
a <<= 1, 2, move(3), 3;

will result in:

1 2 0 0 0 3

References boost::multiprecision::backends::i.

template<std::ptrdiff_t I>

static_vector_move_manip<I> boost::numeric::ublas::move

(

)

An object generator that returns a static move vector index manipulator.

Typically faster than the dynamic version, but can be used only when the values are known at compile time.

Template Parameters

I	The Number of elements the manipulator will traverse the index when manip function is called.Negative values can be used.

Returns

A static move vector manipulator

Example usage:

vector<double> a(6, 0);
a <<= 1, 2, move<3>(), 3;

will result in:

1 2 0 0 0 3

Todo:

Doxygen has some problems with similar template functions. Correct that.

template<typename T >

BOOST_UBLAS_INLINE matrix_move_manip<T> boost::numeric::ublas::move	(	T	i,
		T	j
	)

An object generator that returns a move matrix index manipulator.

Template Parameters

size

type

Parameters

i	The number of rows the manipulator will traverse the index when "manip" member function is called
j	The number of columns the manipulator will traverse the index when "manip" member function is called

Returns

A move matrix manipulator

Example:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, move(1,0),
           3,;

will result in:

1 2 0
0 0 3
0 0 0

References boost::multiprecision::backends::i.

template<std::ptrdiff_t I, std::ptrdiff_t J>

BOOST_UBLAS_INLINE static_matrix_move_manip<I, J> boost::numeric::ublas::move

(

)

An object generator that returns a static "move" matrix index manipulator.

Typically faster than the dynamic version, but can be used only when the values are known at compile time. Negative values can be used.

Template Parameters

I	The number of rows the manipulator will trasverse the matrix assigner index.
J	The number of columns the manipulator will trasverse the matrix assigner index.
size	type

Returns

A static move matrix manipulator

Example:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, move<1,0>(),
           3,;

will result in:

1 2 0
0 0 3
0 0 0

See also

move_to()

Todo:

Doxygen has some problems with similar template functions. Correct that.

template<typename T >

BOOST_UBLAS_INLINE vector_move_to_manip<T> boost::numeric::ublas::move_to

(

T

i

)

An object generator that returns a move_to vector index manipulator.

Parameters

i	The element number the manipulator will move to when manip member function is called

Returns

A move_to vector manipulator

Example usage:

vector<double> a(6, 0);
a <<= 1, 2, move_to(5), 3;

will result in:

1 2 0 0 0 3

Template Parameters

T

Size type

See also

move_to()

References boost::multiprecision::backends::i.

template<std::size_t I>

BOOST_UBLAS_INLINE static_vector_move_to_manip<I> boost::numeric::ublas::move_to

(

)

An object generator that returns a static move_to vector index manipulator.

Typically faster than the dynamic version, but can be used only when the values are known at compile time.

Returns

A static move_to vector manipulator

Example usage:

vector<double> a(6, 0);
a <<= 1, 2, move_to<5>(), 3;

will result in:

1 2 0 0 0 3

Template Parameters

I	The number of elements the manipulator will traverse the index when manip function is called

template<typename T >

BOOST_UBLAS_INLINE matrix_move_to_manip<T> boost::numeric::ublas::move_to	(	T	i,
		T	j
	)

An object generator that returns a "move_to" matrix index manipulator.

Template Parameters

size

type

Parameters

i	The row number the manipulator will move to when manip member function is called
j	The column number the manipulator will move to when manip member function is called

Returns

A move matrix manipulator

Example usage:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, move_to(A.size1()-1, A.size1()-1), 3;

will result in:

1 2 0
0 0 0
0 0 3

See also

move_to(T i, T j) and static_matrix_move_to_manip

Todo:

Doxygen has some problems with similar template functions. Correct that.

References boost::multiprecision::backends::i.

template<std::size_t I, std::size_t J>

BOOST_UBLAS_INLINE static_matrix_move_to_manip<I, J> boost::numeric::ublas::move_to

(

)

An object generator that returns a static move_to matrix index manipulator.

Typically faster than the dynamic version, but can be used only when the values are known at compile time.

Template Parameters

I	The row number the manipulator will set the matrix assigner index to.
J	The column number the manipulator will set the matrix assigner index to.

Returns

A static move_to matrix manipulator

Example usage:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, move_to<2,2>, 3;

will result in:

1 2 0
0 0 0
0 0 3

See also

move_to(T i, T j) and static_matrix_move_to_manip

next_column_manip boost::numeric::ublas::next_column ( )

inline

An object generator that returns a next_row manipulator.

The resulted manipulator will traverse the index to the begining of the next column when it's manip member function is called.

Returns

A next_column matrix manipulator.

Example:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, 0,
     3, next_column(), 4;

will result in:

1 2 4
3 0 0
0 0 0

next_row_manip boost::numeric::ublas::next_row ( )

inline

An object generator that returns a next_row manipulator.

The resulted manipulator will traverse the index to the begining of the next row when it's manip member function is called.

Returns

A next_row matrix manipulator.

Example:

 :
matrix<double> A(3, 3, 0);
A <<= 1, 2, next_row(),
     3, 4;

will result in:

1 2 0
3 4 0
0 0 0

See also

next_column()

template<class E >

BOOST_UBLAS_INLINE vector_scalar_unary_traits<E, vector_norm_1<E> >::result_type boost::numeric::ublas::norm_1

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_scalar_unary_traits<E, matrix_norm_1<E> >::result_type boost::numeric::ublas::norm_1

(

const matrix_expression< E > &

e

)

Referenced by boost::numeric::ublas::blas_1::asum(), axpy_prod(), block_prod(), and opb_prod().

template<class E >

BOOST_UBLAS_INLINE vector_scalar_unary_traits<E, vector_norm_2<E> >::result_type boost::numeric::ublas::norm_2

(

const vector_expression< E > &

e

)

Referenced by boost::numeric::odeint::implicit_euler< ValueType, Resizer >::do_step(), and boost::numeric::ublas::blas_1::nrm2().

template<class E >

BOOST_UBLAS_INLINE matrix_scalar_unary_traits<E, matrix_norm_frobenius<E> >::result_type boost::numeric::ublas::norm_frobenius

(

const matrix_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE vector_scalar_unary_traits<E, vector_norm_inf<E> >::result_type boost::numeric::ublas::norm_inf

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_scalar_unary_traits<E, matrix_norm_inf<E> >::result_type boost::numeric::ublas::norm_inf

(

const matrix_expression< E > &

e

)

Referenced by boost::numeric::ublas::blas_1::amax(), boost::numeric::odeint::mpi_nested_algebra< InnerAlgebra >::norm_inf(), boost::numeric::odeint::multi_array_algebra::norm_inf(), boost::numeric::odeint::range_algebra::norm_inf(), boost::numeric::odeint::openmp_nested_algebra< InnerAlgebra >::norm_inf(), boost::numeric::odeint::vector_space_norm_inf< boost::numeric::ublas::vector< T, A > >::operator()(), and boost::numeric::odeint::vector_space_norm_inf< boost::numeric::ublas::matrix< T, L, A > >::operator()().

template<typename MatrixExprT >

BOOST_UBLAS_INLINE matrix_traits<MatrixExprT>::size_type boost::numeric::ublas::num_columns

(

matrix_expression< MatrixExprT > const &

me

)

Return the number of columns.

Template Parameters

MatrixExprT

A type which models the matrix expression concept.

Parameters

m	A matrix expression.

Returns

The number of columns.

template<typename MatrixExprT >

BOOST_UBLAS_INLINE matrix_traits<MatrixExprT>::size_type boost::numeric::ublas::num_rows

(

matrix_expression< MatrixExprT > const &

me

)

Return the number of rows.

Template Parameters

MatrixExprT

A type which models the matrix expression concept.

Parameters

m	A matrix expression.

Returns

The number of rows.

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::opb_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		dense_proxy_tag	,
		row_major_tag
	)

References BOOST_UBLAS_CHECK, BOOST_UBLAS_SAME, column(), boost::math::tools::epsilon, norm_1(), outer_prod(), prod(), row(), and size().

Referenced by opb_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::opb_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		dense_proxy_tag	,
		column_major_tag
	)

References BOOST_UBLAS_CHECK, BOOST_UBLAS_SAME, column(), boost::math::tools::epsilon, norm_1(), outer_prod(), prod(), row(), and size().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::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.

Parameters

e1	the matrix expression A
e2	the matrix expression X
m	the result matrix M
init	a boolean parameter

opb_prod(A, X, M, init) implements the well known axpy-product. Setting init to true is equivalent to call M.clear() before opb_prod. Currently init defaults to true, but this may change in the future.

This function may give a speedup if A has less columns than rows, because the product is computed as a sum of outer products.

References boost::unit_test::framework::init(), and opb_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::opb_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References opb_prod().

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator* ( I  in1, std::complex< R > const &  in2  )

inline

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator* ( std::complex< R > const &  in1, I  in2  )

inline

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 boost::numeric::ublas::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 boost::numeric::ublas::operator*	(	const vector_expression< E1 > &	e1,
		const T2 &	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 boost::numeric::ublas::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 boost::numeric::ublas::operator*	(	const matrix_expression< E1 > &	e1,
		const T2 &	e2
	)

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator+ ( I  in1, std::complex< R > const &  in2  )

inline

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator+ ( std::complex< R > const &  in1, I  in2  )

inline

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_plus<T1, typename E2::value_type> >::result_type >::type boost::numeric::ublas::operator+	(	const T1 &	e1,
		const vector_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_plus<T1, typename E2::value_type> >::result_type >::type boost::numeric::ublas::operator+	(	const T1 &	e1,
		const matrix_expression< E2 > &	e2
	)

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 boost::numeric::ublas::operator+	(	const vector_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

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 boost::numeric::ublas::operator+	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator- ( I  in1, std::complex< R > const &  in2  )

inline

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator- ( std::complex< R > const &  in1, I  in2  )

inline

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_negate<typename E::value_type> >::result_type boost::numeric::ublas::operator-

(

const vector_expression< E > &

e

)

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 boost::numeric::ublas::operator-	(	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 boost::numeric::ublas::operator-

(

const matrix_expression< E > &

e

)

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 boost::numeric::ublas::operator-	(	const matrix_expression< E1 > &	e1,
		const matrix_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 boost::numeric::ublas::operator/	(	const vector_expression< E1 > &	e1,
		const vector_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 boost::numeric::ublas::operator/	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator/ ( I  in1, std::complex< R > const &  in2  )

inline

template<typename R , typename I >

boost::enable_if< mpl::and_< boost::is_float<R>, boost::is_integral<I> >, std::complex<R> >::type boost::numeric::ublas::operator/ ( std::complex< R > const &  in1, I  in2  )

inline

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 boost::numeric::ublas::operator/	(	const vector_expression< E1 > &	e1,
		const T2 &	e2
	)

template<class E1 , class T2 >

BOOST_UBLAS_INLINE matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type boost::numeric::ublas::operator/	(	const matrix_expression< E1 > &	e1,
		const T2 &	e2
	)

template<class E , class T , class ME >

std::basic_ostream<E, T>& boost::numeric::ublas::operator<<	(	std::basic_ostream< E, T > &	os,
		const matrix_expression< ME > &	m
	)

output stream operator for matrix expressions

it outpus the content of a matrix to a standard output stream using the following format: ,,...,(<mM0>,<mM1>,...,<mMN>))

For example:

matrix<float> m(3,3) = scalar_matrix<float>(3,3,1.0) - diagonal_matrix<float>(3,3,1.0);
cout << m << endl;
\encode
will display
\code
[3,3]((0,1,1),(1,0,1),(1,1,0))

This output is made for storing and retrieving matrices in a simple way but you can easily recognize the following:

Parameters

os	is a standard basic output stream
m	is a matrix expression

Returns

a reference to the resulting output stream

References boost::multiprecision::backends::i, and boost::asio::s.

template<class E , class T , class VE >

std::basic_ostream<E, T>& boost::numeric::ublas::operator<<	(	std::basic_ostream< E, T > &	os,
		const vector_expression< VE > &	v
	)

output stream operator for vector expressions

Any vector expressions can be written to a standard output stream as defined in the C++ standard library. For example:

vector<float> v1(3),v2(3);
for(size_t i=0; i<3; i++)
{
      v1(i) = i+0.2;
      v2(i) = i+0.3;
}
cout << v1+v2 << endl;

will display the some of the 2 vectors like this:

[3](0.5,2.5,4.5)

Parameters

os	is a standard basic output stream
v	is a vector expression

Returns

a reference to the resulting output stream

References boost::multiprecision::backends::i, boost::asio::s, and size().

template<class E >

BOOST_UBLAS_INLINE vector_expression_assigner<vector_expression<E> > boost::numeric::ublas::operator<<=	(	vector_expression< E > &	v,
		const typename E::value_type &	val
	)

A vector_expression_assigner generator used with operator<<= for simple types.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

References boost::phoenix::val().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE vector_expression_assigner<vector_expression<E1> > boost::numeric::ublas::operator<<=	(	vector_expression< E1 > &	v,
		const vector_expression< E2 > &	ve
	)

! A vector_expression_assigner generator used with operator<<= for vector expressions

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

template<class E , typename T >

BOOST_UBLAS_INLINE vector_expression_assigner<vector_expression<E> > boost::numeric::ublas::operator<<=	(	vector_expression< E > &	v,
		const index_manipulator< T > &	nv
	)

A vector_expression_assigner generator used with operator<<= for traverse manipulators.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

template<class E , typename T >

BOOST_UBLAS_INLINE vector_expression_assigner<vector_expression<E>, T> boost::numeric::ublas::operator<<=	(	vector_expression< E > &	v,
		fill_policy_wrapper< T >
	)

A vector_expression_assigner generator used with operator<<= for choice of fill policy.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

References T.

template<class E >

BOOST_UBLAS_INLINE matrix_expression_assigner<matrix_expression<E> > boost::numeric::ublas::operator<<=	(	matrix_expression< E > &	me,
		const typename E::value_type &	val
	)

A matrix_expression_assigner generator used with operator<<= for simple types.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

References boost::phoenix::val().

template<class E , typename T >

BOOST_UBLAS_INLINE matrix_expression_assigner<matrix_expression<E>, T> boost::numeric::ublas::operator<<=	(	matrix_expression< E > &	me,
		fill_policy_wrapper< T >
	)

A matrix_expression_assigner generator used with operator<<= for choice of fill policy.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

References T.

template<class E , typename T >

BOOST_UBLAS_INLINE matrix_expression_assigner<matrix_expression<E> > boost::numeric::ublas::operator<<=	(	matrix_expression< E > &	me,
		const index_manipulator< T > &	ta
	)

A matrix_expression_assigner generator used with operator<<= for traverse manipulators.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

template<class E , typename T >

BOOST_UBLAS_INLINE matrix_expression_assigner<matrix_expression<E>, fill_policy::index_assign, T> boost::numeric::ublas::operator<<=	(	matrix_expression< E > &	me,
		traverse_policy_wrapper< T >
	)

A matrix_expression_assigner generator used with operator<<= for traverse manipulators.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

References T.

template<class E1 , class E2 >

BOOST_UBLAS_INLINE matrix_expression_assigner<matrix_expression<E1> > boost::numeric::ublas::operator<<=	(	matrix_expression< E1 > &	me,
		const vector_expression< E2 > &	ve
	)

A matrix_expression_assigner generator used with operator<<= for vector expressions.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

template<class E1 , class E2 >

BOOST_UBLAS_INLINE matrix_expression_assigner<matrix_expression<E1> > boost::numeric::ublas::operator<<=	(	matrix_expression< E1 > &	me1,
		const matrix_expression< E2 > &	me2
	)

A matrix_expression_assigner generator used with operator<<= for matrix expressions.

Please see EXAMPLES_LINK for usage information.

Todo:

Add examples link

template<class E , class T , class VT , class VA >

std::basic_istream<E, T>& boost::numeric::ublas::operator>>	(	std::basic_istream< E, T > &	is,
		vector< VT, VA > &	v
	)

input stream operator for vectors

This is used to feed in vectors with data stored as an ASCII representation from a standard input stream.

From a file or any valid stream, the format is: like for example:

[5](1,2.1,3.2,3.14,0.2)

You can use it like this

my_input_stream >> my_vector;

You can only put data into a valid vector<> not a vector_expression

Parameters

is	is a standard basic input stream
v	is a vector

Returns

a reference to the resulting input stream

References boost::E, boost::regex_constants::failbit, boost::multiprecision::backends::i, boost::asio::s, size(), and boost::numeric::ublas::vector< T, A >::swap().

template<class E , class T , class MT , class MF , class MA >

std::basic_istream<E, T>& boost::numeric::ublas::operator>>	(	std::basic_istream< E, T > &	is,
		matrix< MT, MF, MA > &	m
	)

input stream operator for matrices

This is used to feed in matrices with data stored as an ASCII representation from a standard input stream.

From a file or any valid standard stream, the format is: ,,...,(<mM0>,<mM1>,...,<mMN>))

You can use it like this

my_input_stream >> my_matrix;

You can only put data into a valid matrix<> not a matrix_expression

Parameters

is	is a standard basic input stream
m	is a matrix

Returns

a reference to the resulting input stream

References boost::E, boost::regex_constants::failbit, boost::multiprecision::backends::i, boost::asio::s, and boost::numeric::ublas::matrix< T, L, A >::swap().

template<class E , class T , class MT , class MF1 , class MF2 , class MA >

std::basic_istream<E, T>& boost::numeric::ublas::operator>>	(	std::basic_istream< E, T > &	is,
		symmetric_matrix< MT, MF1, MF2, MA > &	m
	)

special input stream operator for symmetric matrices

This is used to feed in symmetric matrices with data stored as an ASCII representation from a standard input stream.

You can simply write your matrices in a file or any valid stream and read them again at a later time with this function. The format is the following:

[<rows>,<columns>]((<m00>,<m01>,...,<m0N>),...,(<mM0>,<mM1>,...,<mMN>)) 

You can use it like this

my_input_stream >> my_symmetric_matrix;

You can only put data into a valid symmetric_matrix<>, not in a matrix_expression This function also checks that input data form a valid symmetric matrix

Parameters

is	is a standard basic input stream
m	is a symmetric_matrix

Returns

a reference to the resulting input stream

References boost::E, boost::regex_constants::failbit, boost::multiprecision::backends::i, boost::asio::s, boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::swap(), and boost::program_options::value().

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 boost::numeric::ublas::outer_prod	(	const vector_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT().

Referenced by boost::numeric::ublas::blas_2::gr(), boost::numeric::ublas::blas_2::hr(), boost::numeric::ublas::blas_2::hr2(), lu_factorize(), opb_prod(), boost::numeric::ublas::blas_2::sr(), and boost::numeric::ublas::blas_2::sr2().

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 boost::numeric::ublas::prec_inner_prod	(	const vector_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 boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		unknown_storage_tag	,
		row_major_tag
	)

Referenced by prec_prod().

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 boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT(), and prec_prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v
	)

References prec_prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References prec_prod().

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 boost::numeric::ublas::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 boost::numeric::ublas::prec_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT(), and prec_prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::prec_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		V &	v
	)

References prec_prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::prec_prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References prec_prod().

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 boost::numeric::ublas::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 boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT(), and prec_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m
	)

References prec_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::prec_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References prec_prod().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE matrix_vector_binary1_traits<typename E1::value_type, E1, typename E2::value_type, E2>::result_type boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		unknown_storage_tag	,
		row_major_tag
	)

Referenced by axpy_lu_factorize(), axpy_prod(), block_prod(), boost::numeric::ublas::blas_3::gmm(), boost::numeric::ublas::blas_2::gmv(), boost::numeric::ublas::blas_3::hr2k(), boost::numeric::ublas::blas_3::hrk(), lu_factorize(), lu_substitute(), opb_prod(), prod(), boost::numeric::ublas::blas_3::sr2k(), boost::numeric::ublas::blas_3::srk(), boost::numeric::ublas::blas_3::tmm(), and boost::numeric::ublas::blas_2::tmv().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE matrix_vector_binary1_traits<typename E1::value_type, E1, typename E2::value_type, E2>::result_type boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT(), and prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		V &	v
	)

References prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2
	)

References prod().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE matrix_vector_binary2_traits<typename E1::value_type, E1, typename E2::value_type, E2>::result_type boost::numeric::ublas::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 boost::numeric::ublas::prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT(), and prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V& boost::numeric::ublas::prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		V &	v
	)

References prod().

template<class V , class E1 , class E2 >

BOOST_UBLAS_INLINE V boost::numeric::ublas::prod	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References prod().

template<class E1 , class E2 >

BOOST_UBLAS_INLINE matrix_matrix_binary_traits<typename E1::value_type, E1, typename E2::value_type, E2>::result_type boost::numeric::ublas::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 boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References boost::BOOST_STATIC_ASSERT(), and prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m
	)

References prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References prod().

template<class V >

BOOST_UBLAS_INLINE vector_range<V> boost::numeric::ublas::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.

References boost::proto::envns_::data.

template<class V >

BOOST_UBLAS_INLINE const vector_range<const V> boost::numeric::ublas::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.

References boost::proto::envns_::data.

template<class V >

BOOST_UBLAS_INLINE vector_range<V> boost::numeric::ublas::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> boost::numeric::ublas::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> boost::numeric::ublas::project	(	V &	data,
		const typename vector_slice< V >::slice_type &	s
	)

References boost::proto::envns_::data, and boost::asio::s.

template<class V >

BOOST_UBLAS_INLINE const vector_slice<const V> boost::numeric::ublas::project	(	const V &	data,
		const typename vector_slice< V >::slice_type &	s
	)

References boost::proto::envns_::data, and boost::asio::s.

template<class V >

BOOST_UBLAS_INLINE vector_slice<V> boost::numeric::ublas::project	(	vector_slice< V > &	data,
		const typename vector_slice< V >::slice_type &	s
	)

References boost::numeric::ublas::vector_slice< V >::project().

template<class V >

BOOST_UBLAS_INLINE const vector_slice<V> boost::numeric::ublas::project	(	const vector_slice< V > &	data,
		const typename vector_slice< V >::slice_type &	s
	)

References boost::numeric::ublas::vector_slice< V >::project().

template<class V >

BOOST_UBLAS_INLINE vector_slice<V> boost::numeric::ublas::project	(	vector_slice< V > &	data,
		const typename vector_range< V >::range_type &	r
	)

References boost::numeric::ublas::vector_slice< V >::project().

template<class V >

BOOST_UBLAS_INLINE const vector_slice<V> boost::numeric::ublas::project	(	const vector_slice< V > &	data,
		const typename vector_range< V >::range_type &	r
	)

References boost::numeric::ublas::vector_slice< V >::project().

template<class V , class A >

BOOST_UBLAS_INLINE vector_indirect<V, indirect_array<A> > boost::numeric::ublas::project	(	V &	data,
		const indirect_array< A > &	ia
	)

References boost::proto::envns_::data.

template<class V , class A >

BOOST_UBLAS_INLINE const vector_indirect<const V, indirect_array<A> > boost::numeric::ublas::project	(	const V &	data,
		const indirect_array< A > &	ia
	)

References boost::proto::envns_::data.

template<class V , class IA >

BOOST_UBLAS_INLINE vector_indirect<V, IA> boost::numeric::ublas::project	(	vector_indirect< V, IA > &	data,
		const typename vector_indirect< V, IA >::range_type &	r
	)

References boost::numeric::ublas::vector_indirect< V, IA >::project().

template<class V , class IA >

BOOST_UBLAS_INLINE const vector_indirect<V, IA> boost::numeric::ublas::project	(	const vector_indirect< V, IA > &	data,
		const typename vector_indirect< V, IA >::range_type &	r
	)

References boost::numeric::ublas::vector_indirect< V, IA >::project().

template<class V , class IA >

BOOST_UBLAS_INLINE vector_indirect<V, IA> boost::numeric::ublas::project	(	vector_indirect< V, IA > &	data,
		const typename vector_indirect< V, IA >::slice_type &	s
	)

References boost::numeric::ublas::vector_indirect< V, IA >::project().

template<class V , class IA >

BOOST_UBLAS_INLINE const vector_indirect<V, IA> boost::numeric::ublas::project	(	const vector_indirect< V, IA > &	data,
		const typename vector_indirect< V, IA >::slice_type &	s
	)

References boost::numeric::ublas::vector_indirect< V, IA >::project().

template<class V , class A >

BOOST_UBLAS_INLINE vector_indirect<V, indirect_array<A> > boost::numeric::ublas::project	(	vector_indirect< V, indirect_array< A > > &	data,
		const indirect_array< A > &	ia
	)

References boost::proto::envns_::data.

template<class V , class A >

BOOST_UBLAS_INLINE const vector_indirect<V, indirect_array<A> > boost::numeric::ublas::project	(	const vector_indirect< V, indirect_array< A > > &	data,
		const indirect_array< A > &	ia
	)

References boost::proto::envns_::data.

template<class M >

BOOST_UBLAS_INLINE matrix_range<M> boost::numeric::ublas::project	(	M &	data,
		const typename matrix_range< M >::range_type &	r1,
		const typename matrix_range< M >::range_type &	r2
	)

References boost::proto::envns_::data.

Referenced by axpy_lu_factorize(), block_prod(), and lu_factorize().

template<class M >

BOOST_UBLAS_INLINE const matrix_range<const M> boost::numeric::ublas::project	(	const M &	data,
		const typename matrix_range< M >::range_type &	r1,
		const typename matrix_range< M >::range_type &	r2
	)

References boost::proto::envns_::data.

template<class M >

BOOST_UBLAS_INLINE matrix_range<M> boost::numeric::ublas::project	(	matrix_range< M > &	data,
		const typename matrix_range< M >::range_type &	r1,
		const typename matrix_range< M >::range_type &	r2
	)

References boost::numeric::ublas::matrix_range< M >::project().

template<class M >

BOOST_UBLAS_INLINE const matrix_range<M> boost::numeric::ublas::project	(	const matrix_range< M > &	data,
		const typename matrix_range< M >::range_type &	r1,
		const typename matrix_range< M >::range_type &	r2
	)

References boost::numeric::ublas::matrix_range< M >::project().

template<class M >

BOOST_UBLAS_INLINE matrix_slice<M> boost::numeric::ublas::project	(	M &	data,
		const typename matrix_slice< M >::slice_type &	s1,
		const typename matrix_slice< M >::slice_type &	s2
	)

References boost::proto::envns_::data, boost::xpressive::s1, and boost::xpressive::s2.

template<class M >

BOOST_UBLAS_INLINE const matrix_slice<const M> boost::numeric::ublas::project	(	const M &	data,
		const typename matrix_slice< M >::slice_type &	s1,
		const typename matrix_slice< M >::slice_type &	s2
	)

References boost::proto::envns_::data, boost::xpressive::s1, and boost::xpressive::s2.

template<class M >

BOOST_UBLAS_INLINE matrix_slice<M> boost::numeric::ublas::project	(	matrix_slice< M > &	data,
		const typename matrix_range< M >::range_type &	r1,
		const typename matrix_range< M >::range_type &	r2
	)

References boost::numeric::ublas::matrix_slice< M >::project().

template<class M >

BOOST_UBLAS_INLINE const matrix_slice<M> boost::numeric::ublas::project	(	const matrix_slice< M > &	data,
		const typename matrix_range< M >::range_type &	r1,
		const typename matrix_range< M >::range_type &	r2
	)

References boost::numeric::ublas::matrix_slice< M >::project().

template<class M >

BOOST_UBLAS_INLINE matrix_slice<M> boost::numeric::ublas::project	(	matrix_slice< M > &	data,
		const typename matrix_slice< M >::slice_type &	s1,
		const typename matrix_slice< M >::slice_type &	s2
	)

References boost::numeric::ublas::matrix_slice< M >::project().

template<class M >

BOOST_UBLAS_INLINE const matrix_slice<M> boost::numeric::ublas::project	(	const matrix_slice< M > &	data,
		const typename matrix_slice< M >::slice_type &	s1,
		const typename matrix_slice< M >::slice_type &	s2
	)

References boost::numeric::ublas::matrix_slice< M >::project().

template<class M , class A >

BOOST_UBLAS_INLINE matrix_indirect<M, indirect_array<A> > boost::numeric::ublas::project	(	M &	data,
		const indirect_array< A > &	ia1,
		const indirect_array< A > &	ia2
	)

References boost::proto::envns_::data.

template<class M , class A >

BOOST_UBLAS_INLINE const matrix_indirect<const M, indirect_array<A> > boost::numeric::ublas::project	(	const M &	data,
		const indirect_array< A > &	ia1,
		const indirect_array< A > &	ia2
	)

References boost::proto::envns_::data.

template<class M , class IA >

BOOST_UBLAS_INLINE matrix_indirect<M, IA> boost::numeric::ublas::project	(	matrix_indirect< M, IA > &	data,
		const typename matrix_indirect< M, IA >::range_type &	r1,
		const typename matrix_indirect< M, IA >::range_type &	r2
	)

References boost::numeric::ublas::matrix_indirect< M, IA >::project().

template<class M , class IA >

BOOST_UBLAS_INLINE const matrix_indirect<M, IA> boost::numeric::ublas::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
	)

References boost::numeric::ublas::matrix_indirect< M, IA >::project().

template<class M , class IA >

BOOST_UBLAS_INLINE matrix_indirect<M, IA> boost::numeric::ublas::project	(	matrix_indirect< M, IA > &	data,
		const typename matrix_indirect< M, IA >::slice_type &	s1,
		const typename matrix_indirect< M, IA >::slice_type &	s2
	)

References boost::numeric::ublas::matrix_indirect< M, IA >::project().

template<class M , class IA >

BOOST_UBLAS_INLINE const matrix_indirect<M, IA> boost::numeric::ublas::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
	)

References boost::numeric::ublas::matrix_indirect< M, IA >::project().

template<class M , class A >

BOOST_UBLAS_INLINE matrix_indirect<M, indirect_array<A> > boost::numeric::ublas::project	(	matrix_indirect< M, indirect_array< A > > &	data,
		const indirect_array< A > &	ia1,
		const indirect_array< A > &	ia2
	)

References boost::proto::envns_::data.

template<class M , class A >

BOOST_UBLAS_INLINE const matrix_indirect<M, indirect_array<A> > boost::numeric::ublas::project	(	const matrix_indirect< M, indirect_array< A > > &	data,
		const indirect_array< A > &	ia1,
		const indirect_array< A > &	ia2
	)

References boost::proto::envns_::data.

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_real<typename E::value_type> >::result_type boost::numeric::ublas::real

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_unary1_traits<E, scalar_real<typename E::value_type> >::result_type boost::numeric::ublas::real

(

const matrix_expression< E > &

e

)

template<class M >

BOOST_UBLAS_INLINE matrix_row<M> boost::numeric::ublas::row	(	M &	data,
		typename M::size_type	i
	)

References boost::proto::envns_::data, and boost::multiprecision::backends::i.

Referenced by boost::gil::detail::jpeg_reader::apply(), boost::gil::detail::tiff_reader::apply(), boost::gil::detail::jpeg_reader_color_convert< CC >::apply(), boost::gil::detail::png_reader::apply(), boost::gil::detail::tiff_reader_color_convert< CC >::apply(), boost::gil::detail::jpeg_writer::apply(), boost::gil::detail::png_reader_color_convert< CC >::apply(), boost::gil::detail::tiff_writer::apply(), boost::gil::detail::png_writer::apply(), boost::numeric::ublas::matrix_vector_prod1< M1, M2, TV >::apply(), boost::numeric::ublas::matrix_matrix_prod< M1, M2, TV >::apply(), axpy_lu_factorize(), axpy_prod(), boost::hawick_circuits_detail::call_hawick_circuits(), lu_factorize(), opb_prod(), boost::grid_force_pairs< Topology, PositionMap >::operator()(), and swap_rows().

template<class M >

BOOST_UBLAS_INLINE const matrix_row<const M> boost::numeric::ublas::row	(	const M &	data,
		typename M::size_type	i
	)

References boost::proto::envns_::data, and boost::multiprecision::backends::i.

template<class T1 , class T2 >

BOOST_UBLAS_INLINE T1 boost::numeric::ublas::same_impl_ex	(	const T1 &	size1,
		const T2 &	size2,
		const char *	file,
		int	line
	)

References BOOST_UBLAS_CHECK_EX.

template<class T >

BOOST_UBLAS_INLINE T boost::numeric::ublas::same_impl_ex	(	const T &	size1,
		const T &	size2,
		const char *	file,
		int	line
	)

References BOOST_UBLAS_CHECK_EX, and boost::accumulators::extract::min.

template<typename VectorExprT >

BOOST_UBLAS_INLINE typename ::boost::lazy_enable_if_c< detail::has_size_type<VectorExprT>::value, detail::vector_size_type<VectorExprT>>::type boost::numeric::ublas::size

(

vector_expression< VectorExprT > const &

ve

)

Return the number of columns.

Template Parameters

VectorExprT

A type which models the vector expression concept.

Parameters

ve	A vector expression.

Returns

The length of the input vector expression.

Referenced by boost::numeric::ublas::vector_sum< V >::apply(), boost::numeric::ublas::vector_norm_1< V >::apply(), boost::numeric::ublas::vector_norm_2< V >::apply(), boost::numeric::ublas::vector_norm_inf< V >::apply(), boost::numeric::ublas::vector_index_norm_inf< V >::apply(), boost::numeric::ublas::vector_inner_prod< V1, V2, TV >::apply(), boost::numeric::ublas::matrix_vector_prod1< M1, M2, TV >::apply(), boost::numeric::ublas::matrix_vector_prod2< M1, M2, TV >::apply(), boost::numeric::ublas::matrix_matrix_prod< M1, M2, TV >::apply(), axpy_lu_factorize(), block_prod(), inplace_solve(), is_hermitian(), is_symmetric(), lu_factorize(), boost::numeric::ublas::mapped_matrix< T, L, A >::nnz(), opb_prod(), operator<<(), operator>>(), boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::resize(), boost::numeric::ublas::hermitian_matrix< T, TRI, L, A >::resize(), boost::numeric::ublas::zero_matrix< T, ALLOC >::resize(), boost::numeric::ublas::identity_matrix< T, ALLOC >::resize(), swap_rows(), boost::numeric::ublas::basic_row_major< Z, D >::triangular_size(), and boost::numeric::ublas::basic_column_major< Z, D >::triangular_size().

template<std::size_t Dim, typename VectorExprT >

BOOST_UBLAS_INLINE vector_traits<VectorExprT>::size_type boost::numeric::ublas::size

(

vector_expression< VectorExprT > const &

ve

)

Return the size of the given dimension for the given vector expression.

Template Parameters

Dim	The dimension number (starting from 1).
VectorExprT	A vector expression type.

Parameters

ve	A vector expression.

Returns

The length of the input vector expression.

template<std::size_t Dim, typename MatrixExprT >

BOOST_UBLAS_INLINE matrix_traits<MatrixExprT>::size_type boost::numeric::ublas::size

(

matrix_expression< MatrixExprT > const &

me

)

Return the size of the given dimension for the given matrix expression.

Template Parameters

Dim	The dimension number (starting from 1).
MatrixExprT	A matrix expression type.

Parameters

e	A matrix expression.

Returns

The size of the input matrix expression associated to the dimension Dim.

template<typename TagT , typename MatrixExprT >

BOOST_UBLAS_INLINE typename ::boost::lazy_enable_if_c< detail::has_size_type<MatrixExprT>::value, detail::matrix_size_type<MatrixExprT>>::type boost::numeric::ublas::size

(

matrix_expression< MatrixExprT > const &

me

)

Return the size of the given dimension tag for the given matrix expression.

Template Parameters

TagT	The dimension tag type (e.g., tag::major).
MatrixExprT	A matrix expression type.

Parameters

e	A matrix expression.

Returns

The size of the input matrix expression associated to the dimension tag TagT.

template<class E1 , class E2 , class C >

BOOST_UBLAS_INLINE matrix_vector_solve_traits<E1, E2>::result_type boost::numeric::ublas::solve	(	const matrix_expression< E1 > &	e1,
		const vector_expression< E2 > &	e2,
		C
	)

References inplace_solve().

Referenced by axpy_lu_factorize(), boost::detail::graph::kamada_kawai_spring_layout_impl< Topology, Graph, PositionMap, WeightMap, EdgeOrSideLength, Done, VertexIndexMap, DistanceMatrix, SpringStrengthMatrix, PartialDerivativeMap >::run(), boost::numeric::ublas::blas_3::tsm(), and boost::numeric::ublas::blas_2::tsv().

template<class E1 , class E2 , class C >

BOOST_UBLAS_INLINE matrix_vector_solve_traits<E1, E2>::result_type boost::numeric::ublas::solve	(	const vector_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		C
	)

References inplace_solve().

template<class E1 , class E2 , class C >

BOOST_UBLAS_INLINE matrix_matrix_solve_traits<E1, E2>::result_type boost::numeric::ublas::solve	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		C
	)

References inplace_solve().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::sparse_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		row_major_tag
	)

References begin(), begin1(), boost::numeric::ublas::vector< T, A >::clear(), end(), boost::accumulators::extract::max, boost::accumulators::extract::min, boost::spirit::x3::unicode::other, and boost::numeric::ublas::vector< T, A >::size().

Referenced by sparse_prod().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::sparse_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		column_major_tag
	)

References begin(), begin2(), boost::numeric::ublas::vector< T, A >::clear(), end(), boost::multiprecision::backends::i, boost::accumulators::extract::max, boost::accumulators::extract::min, boost::spirit::x3::unicode::other, and boost::numeric::ublas::vector< T, A >::size().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::sparse_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		TRI	,
		bool	init = true
	)

References boost::unit_test::framework::init(), and sparse_prod().

template<class M , class E1 , class E2 , class TRI >

BOOST_UBLAS_INLINE M boost::numeric::ublas::sparse_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		TRI
	)

References sparse_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M& boost::numeric::ublas::sparse_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2,
		M &	m,
		bool	init = true
	)

References boost::unit_test::framework::init(), and sparse_prod().

template<class M , class E1 , class E2 >

BOOST_UBLAS_INLINE M boost::numeric::ublas::sparse_prod	(	const matrix_expression< E1 > &	e1,
		const matrix_expression< E2 > &	e2
	)

References sparse_prod().

template<class V >

BOOST_UBLAS_INLINE vector_range<V> boost::numeric::ublas::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.

References boost::proto::envns_::data.

template<class V >

BOOST_UBLAS_INLINE vector_range<const V> boost::numeric::ublas::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.

References boost::proto::envns_::data.

template<class M >

BOOST_UBLAS_INLINE matrix_range<M> boost::numeric::ublas::subrange	(	M &	data,
		typename M::size_type	start1,
		typename M::size_type	stop1,
		typename M::size_type	start2,
		typename M::size_type	stop2
	)

References boost::proto::envns_::data.

template<class M >

BOOST_UBLAS_INLINE matrix_range<const M> boost::numeric::ublas::subrange	(	const M &	data,
		typename M::size_type	start1,
		typename M::size_type	stop1,
		typename M::size_type	start2,
		typename M::size_type	stop2
	)

References boost::proto::envns_::data.

template<class V >

BOOST_UBLAS_INLINE vector_slice<V> boost::numeric::ublas::subslice	(	V &	data,
		typename V::size_type	start,
		typename V::difference_type	stride,
		typename V::size_type	size
	)

References boost::proto::envns_::data.

template<class V >

BOOST_UBLAS_INLINE vector_slice<const V> boost::numeric::ublas::subslice	(	const V &	data,
		typename V::size_type	start,
		typename V::difference_type	stride,
		typename V::size_type	size
	)

References boost::proto::envns_::data.

template<class M >

BOOST_UBLAS_INLINE matrix_slice<M> boost::numeric::ublas::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
	)

References boost::proto::envns_::data.

template<class M >

BOOST_UBLAS_INLINE matrix_slice<const M> boost::numeric::ublas::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
	)

References boost::proto::envns_::data.

template<class E >

BOOST_UBLAS_INLINE vector_scalar_unary_traits<E, vector_sum<E> >::result_type boost::numeric::ublas::sum

(

const vector_expression< E > &

e

)

template<class PM , class MV >

BOOST_UBLAS_INLINE void boost::numeric::ublas::swap_rows	(	const PM &	pm,
		MV &	mv,
		vector_tag
	)

References boost::multiprecision::backends::i, size(), and boost::swap.

Referenced by axpy_lu_factorize(), lu_factorize(), lu_substitute(), and swap_rows().

template<class PM , class MV >

BOOST_UBLAS_INLINE void boost::numeric::ublas::swap_rows	(	const PM &	pm,
		MV &	mv,
		matrix_tag
	)

References boost::multiprecision::backends::i, row(), and size().

template<class PM , class MV >

BOOST_UBLAS_INLINE void boost::numeric::ublas::swap_rows	(	const PM &	pm,
		MV &	mv
	)

References swap_rows().

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<const E, scalar_identity<typename E::value_type> >::result_type boost::numeric::ublas::trans

(

const vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE vector_unary_traits<E, scalar_identity<typename E::value_type> >::result_type boost::numeric::ublas::trans

(

vector_expression< E > &

e

)

template<class E >

BOOST_UBLAS_INLINE matrix_unary2_traits<const E, scalar_identity<typename E::value_type> >::result_type boost::numeric::ublas::trans

(

const matrix_expression< E > &

e

)

Referenced by inplace_solve(), boost::numeric::ublas::blas_3::sr2k(), and boost::numeric::ublas::blas_3::srk().

template<class E >

BOOST_UBLAS_INLINE matrix_unary2_traits<E, scalar_identity<typename E::value_type> >::result_type boost::numeric::ublas::trans

(

matrix_expression< E > &

e

)