Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
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 $M$ by $N$. More...
 
class  bounded_vector
 a dense vector of values of type T, of variable size but with maximum $N$. 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

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)
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)
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   
)
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   
)
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 
)
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 
)
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
e1the matrix expression A
e2the vector expression x
vthe result vector v
inita 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   
)
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   
)
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 
)
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 
)
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
e1the vector expression x
e2the matrix expression A
vthe result vector v
inita 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   
)
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   
)
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   
)
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   
)
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 
)
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
e1the matrix expression A
e2the matrix expression X
mthe result matrix M
inita 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
ExprTA model of VectorExpression type.
Parameters
eA 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
ExprTA model of VectorExpression type.
Parameters
eA 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
DimTagTA dimension tag type (e.g., tag::major).
ExprTA model of MatrixExpression type.
Parameters
eA 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
TagTA dimension tag type (e.g., tag::major).
ExprTA model of MatrixExpression type.
Parameters
eA 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
IteratorTA model of Iterator type.
Parameters
itAn 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
IteratorTA model of Iterator type.
Parameters
itAn 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 
)
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 
)
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   
)
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   
)
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 const matrix_column<const M> boost::numeric::ublas::column ( const M &  data,
typename M::size_type  j 
)
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)
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
ExprTA model of VectorExpression type.
Parameters
eA 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
ExprTA model of VectorExpression type.
Parameters
eA 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
DimTagTA dimension tag type (e.g., tag::major).
ExprTA model of MatrixExpression type.
Parameters
eA 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
TagTA dimension tag type (e.g., tag::major).
ExprTA model of MatrixExpression type.
Parameters
eA 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
IteratorTA model of Iterator type.
Parameters
itAn 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
IteratorTA model of Iterator type.
Parameters
itAn 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)
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 
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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   
)
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)
template<class M >
bool boost::numeric::ublas::is_symmetric ( const M &  m)
template<class M , class PM >
M::size_type boost::numeric::ublas::lu_factorize ( M &  m,
PM &  pm 
)
template<class M , class E >
void boost::numeric::ublas::lu_substitute ( const M &  m,
matrix_expression< E > &  e 
)
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 
)
template<class E , class M >
void boost::numeric::ublas::lu_substitute ( matrix_expression< E > &  e,
const M &  m 
)
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
matrixthe matrix_expression that generates the matrix that matrix_column_vector is referring.
Returns
Created matrix_column_vector object.
Template Parameters
Matrixthe 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
matrixthe matrix_expression that generates the matrix that matrix_column_vector is referring.
Returns
Created matrix_column_vector object.
Template Parameters
Matrixthe 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
matrixthe matrix_expression that generates the matrix that matrix_row_vector is referring.
Returns
Created matrix_row_vector object.
Template Parameters
Matrixthe 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
matrixthe matrix_expression that generates the matrix that matrix_row_vector is referring.
Returns
Created matrix_row_vector object.
Template Parameters
Matrixthe 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
TSize type
Parameters
iThe 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
IThe 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
sizetype
Parameters
iThe number of rows the manipulator will traverse the index when "manip" member function is called
jThe 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
IThe number of rows the manipulator will trasverse the matrix assigner index.
JThe number of columns the manipulator will trasverse the matrix assigner index.
sizetype
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
iThe 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
TSize 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
IThe 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
sizetype
Parameters
iThe row number the manipulator will move to when manip member function is called
jThe 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
IThe row number the manipulator will set the matrix assigner index to.
JThe 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)
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)
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<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
MatrixExprTA type which models the matrix expression concept.
Parameters
mA 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
MatrixExprTA type which models the matrix expression concept.
Parameters
mA 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   
)
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   
)
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
e1the matrix expression A
e2the matrix expression X
mthe result matrix M
inita 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* ( 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,
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+ ( 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,
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- ( 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,
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/ ( 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,
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 $(M \times N)$ 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;
will display
[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:

\[ \left( \begin{array}{ccc} 1 & 1 & 1\\ 1 & 1 & 1\\ 1 & 1 & 1 \end{array} \right) - \left( \begin{array}{ccc} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1 \end{array} \right) = \left( \begin{array}{ccc} 0 & 1 & 1\\ 1 & 0 & 1\\ 1 & 1 & 0 \end{array} \right) \]

Parameters
osis a standard basic output stream
mis 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
osis a standard basic output stream
vis 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
isis a standard basic input stream
vis 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
isis a standard basic input stream
mis 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
isis a standard basic input stream
mis 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 
)
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 
)
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 
)
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 
)
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   
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 const matrix_row<const M> boost::numeric::ublas::row ( const M &  data,
typename M::size_type  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 
)
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)
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
DimThe dimension number (starting from 1).
VectorExprTA vector expression type.
Parameters
veA 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
DimThe dimension number (starting from 1).
MatrixExprTA matrix expression type.
Parameters
eA 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
TagTThe dimension tag type (e.g., tag::major).
MatrixExprTA matrix expression type.
Parameters
eA 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 vector_expression< E1 > &  e1,
const matrix_expression< E2 > &  e2,
 
)

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,
 
)

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   
)
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   
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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 
)
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   
)
template<class PM , class MV >
BOOST_UBLAS_INLINE void boost::numeric::ublas::swap_rows ( const PM &  pm,
MV &  mv,
matrix_tag   
)
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)
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)