Bayesian Filtering Library  Generated from SVN r
Classes | Typedefs | Functions
BFL::boost::numeric::ublas Namespace Reference

main namespace of uBLAS. More...

Classes

class  unbounded_array
 
class  bounded_array
 
class  basic_range
 
class  basic_slice
 
class  indirect_array
 
class  map_std
 
class  map_array
 
struct  scalar_tag
 
struct  vector_tag
 
class  vector_expression
 Base class for Vector Expression models. More...
 
class  vector_container
 Base class for Vector container models. More...
 
class  vector_reference
 
struct  matrix_tag
 
class  matrix_expression
 Base class for Matrix Expression models. More...
 
class  matrix_container
 Base class for Matrix container models. More...
 
class  matrix_reference
 
class  vector_range
 A vector referencing a continuous subvector of elements of vector v containing all elements specified by range. More...
 
class  vector_slice
 A vector referencing a non continuous subvector of elements of vector v containing all elements specified by slice. More...
 
class  vector_indirect
 A vector referencing a non continuous subvector of elements given another vector of indices. More...
 
class  matrix_row
 
class  matrix_column
 
class  matrix_vector_range
 
class  matrix_vector_slice
 
class  matrix_vector_indirect
 
class  matrix_range
 
class  matrix_slice
 
class  matrix_indirect
 A matrix referencing a non continuous submatrix of elements given another matrix of indices. More...
 
class  vector
 A dense vector of values of type T. More...
 
class  bounded_vector
 a dense vector of values of type T, of variable size but with maximum $N$. A dense vector of values of type T, of variable size but with maximum $N$. The default constructor creates the vector with size $N$. Elements are constructed by the storage type bounded_array, which need not initialise their value. More...
 
class  unit_vector
 unit_vector represents a canonical unit vector unit_vector represents a canonical unit vector. The k-th unit vector of dimension $n$ holds 0 for every value $u_i$ s.t. $i \neq k$ and 1 when $i=k$. At construction, the value k is given after the dimension of the vector. More...
 
class  zero_vector
 A zero vector of type T and a given size A zero vector of type T and a given size. This is a virtual vector in the sense that no memory is allocated for storing the zero values: it still acts like any other vector. However assigning values to it will not change the zero vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant. More...
 
class  scalar_vector
 A scalar (i.e. unique value) vector of type T and a given size A scalar (i.e. unique value) vector of type T and a given size. This is a virtual vector in the sense that no memory is allocated for storing the unique value more than once: it still acts like any other vector. However assigning a new value will change all the value at once. vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant. 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...
 
class  mapped_vector
 
class  compressed_vector
 
class  coordinate_vector
 
struct  unknown_orientation_tag
 
struct  row_major_tag
 
struct  column_major_tag
 
struct  basic_row_major
 
struct  basic_column_major
 
class  matrix
 A dense matrix of values of type T. More...
 
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  identity_matrix
 An identity matrix with values of type T. More...
 
class  zero_matrix
 A matrix with all values of type T equal to zero. More...
 
class  scalar_matrix
 A matrix with all values of type T equal to the same value. More...
 
class  c_matrix
 An array based matrix class which size is defined at type specification or object instanciation. More...
 
class  vector_of_vector
 A dense matrix of values of type T stored as a vector of vectors. More...
 
class  generalized_vector_of_vector
 
struct  lower_tag
 
struct  upper_tag
 
struct  unit_lower_tag
 
struct  unit_upper_tag
 
struct  strict_lower_tag
 
struct  strict_upper_tag
 
struct  basic_full
 
struct  basic_lower
 
struct  basic_upper
 
struct  basic_unit_lower
 
struct  basic_unit_upper
 
struct  basic_strict_lower
 
struct  basic_strict_upper
 
class  banded_matrix
 
class  diagonal_matrix
 
class  triangular_matrix
 A triangular matrix of values of type T. More...
 
class  triangular_adaptor
 
class  symmetric_matrix
 
class  symmetric_adaptor
 
class  hermitian_matrix
 
class  hermitian_adaptor
 
class  mapped_matrix
 
class  mapped_vector_of_mapped_vector
 
class  compressed_matrix
 
class  coordinate_matrix
 
class  noalias_proxy
 
struct  divide_by_zero
 Exception raised when a division by zero occurs. More...
 
struct  internal_logic
 Expception raised when some interal errors occurs like computations errors, zeros values where you should not have zeros, etc... More...
 
struct  external_logic
 
struct  bad_argument
 
struct  bad_size
 
struct  bad_index
 
struct  singular
 
struct  non_real
 
class  container_const_reference
 Base class of all proxy classes that contain a (redirectable) reference to an immutable object. More...
 
class  container_reference
 Base class of all proxy classes that contain a (redirectable) reference to a mutable object. More...
 
struct  forward_iterator_base
 Base class of all forward iterators. More...
 
struct  bidirectional_iterator_base
 Base class of all bidirectional iterators. More...
 
struct  random_access_iterator_base
 Base class of all random access iterators. More...
 
class  reverse_iterator_base
 Base class of all reverse iterators. (non-MSVC version) More...
 
class  reverse_iterator_base1
 1st base class of all matrix reverse iterators. (non-MSVC version) More...
 
class  reverse_iterator_base2
 2nd base class of all matrix reverse iterators. (non-MSVC version) More...
 
class  indexed_iterator
 A class implementing an indexed random access iterator. More...
 
class  indexed_const_iterator
 A class implementing an indexed random access iterator. More...
 
class  indexed_iterator2
 A class implementing an indexed random access iterator of a matrix. More...
 
class  indexed_iterator1
 A class implementing an indexed random access iterator of a matrix. More...
 
class  indexed_const_iterator2
 A class implementing an indexed random access iterator of a matrix. More...
 
class  indexed_const_iterator1
 A class implementing an indexed random access iterator of a matrix. More...
 
struct  error_cant_deduce_type
 
struct  promote_traits
 
struct  type_traits
 
struct  scalar_traits
 
struct  type_traits< float >
 
struct  type_traits< double >
 
struct  type_traits< long double >
 
struct  complex_traits
 
struct  type_traits< std::complex< float > >
 
struct  type_traits< std::complex< double > >
 
struct  type_traits< std::complex< long double > >
 
struct  unknown_storage_tag
 
struct  sparse_proxy_tag
 
struct  sparse_tag
 
struct  packed_proxy_tag
 
struct  packed_tag
 
struct  dense_proxy_tag
 
struct  dense_tag
 
struct  storage_restrict_traits
 
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  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< packed_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< dense_proxy_tag, packed_proxy_tag >
 
struct  storage_restrict_traits< dense_proxy_tag, sparse_proxy_tag >
 
struct  sparse_bidirectional_iterator_tag
 
struct  packed_random_access_iterator_tag
 
struct  dense_random_access_iterator_tag
 
struct  iterator_base_traits
 
struct  iterator_base_traits< std::forward_iterator_tag >
 
struct  iterator_base_traits< std::bidirectional_iterator_tag >
 
struct  iterator_base_traits< sparse_bidirectional_iterator_tag >
 
struct  iterator_base_traits< std::random_access_iterator_tag >
 
struct  iterator_base_traits< packed_random_access_iterator_tag >
 
struct  iterator_base_traits< dense_random_access_iterator_tag >
 
struct  iterator_restrict_traits
 
struct  iterator_restrict_traits< packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  iterator_restrict_traits< sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag >
 
struct  iterator_restrict_traits< dense_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< dense_random_access_iterator_tag, packed_random_access_iterator_tag >
 
struct  iterator_restrict_traits< packed_random_access_iterator_tag, dense_random_access_iterator_tag >
 
struct  container_view_traits
 Traits class to extract type information from a constant matrix or vector CONTAINER. More...
 
struct  mutable_container_traits
 Traits class to extract additional type information from a mutable matrix or vector CONTAINER. More...
 
struct  container_traits
 Traits class to extract type information from a matrix or vector CONTAINER. More...
 
struct  matrix_view_traits
 Traits class to extract type information from a constant MATRIX. More...
 
struct  mutable_matrix_traits
 Traits class to extract additional type information from a mutable MATRIX. More...
 
struct  matrix_traits
 Traits class to extract type information from a MATRIX. More...
 
struct  vector_view_traits
 Traits class to extract type information from a VECTOR. More...
 
struct  mutable_vector_traits
 Traits class to extract type information from a VECTOR. More...
 
struct  vector_traits
 Traits class to extract type information from a VECTOR. More...
 
class  storage_array
 
class  array_adaptor
 
class  index_pair
 
class  index_pair_array
 
class  index_triple
 
class  index_triple_array
 
struct  scalar_unary_functor
 
struct  scalar_identity
 
struct  scalar_negate
 
struct  scalar_conj
 
struct  scalar_real_unary_functor
 
struct  scalar_real
 
struct  scalar_imag
 
struct  scalar_binary_functor
 
struct  scalar_plus
 
struct  scalar_minus
 
struct  scalar_multiplies
 
struct  scalar_divides
 
struct  scalar_binary_assign_functor
 
struct  assign_tag
 
struct  computed_assign_tag
 
struct  scalar_assign
 
struct  scalar_plus_assign
 
struct  scalar_minus_assign
 
struct  scalar_multiplies_assign
 
struct  scalar_divides_assign
 
struct  scalar_binary_swap_functor
 
struct  scalar_swap
 
struct  vector_scalar_unary_functor
 
struct  vector_sum
 
struct  vector_scalar_real_unary_functor
 
struct  vector_norm_1
 
struct  vector_norm_2
 
struct  vector_norm_inf
 
struct  vector_scalar_index_unary_functor
 
struct  vector_index_norm_inf
 
struct  vector_scalar_binary_functor
 
struct  vector_inner_prod
 
struct  matrix_vector_binary_functor
 
struct  matrix_vector_prod1
 
struct  matrix_vector_prod2
 
struct  matrix_matrix_binary_functor
 
struct  matrix_matrix_prod
 
struct  matrix_scalar_real_unary_functor
 
struct  matrix_norm_1
 
struct  matrix_norm_frobenius
 
struct  matrix_norm_inf
 
class  ublas_expression
 Base class for uBLAS statically derived expressions using the the Barton Nackman trick. More...
 
class  scalar_expression
 Base class for Scalar Expression models. More...
 
class  scalar_reference
 
class  scalar_value
 
class  vector_unary
 
struct  vector_unary_traits
 
class  vector_binary
 
struct  vector_binary_traits
 
class  vector_binary_scalar1
 
struct  vector_binary_scalar1_traits
 
class  vector_binary_scalar2
 
struct  vector_binary_scalar2_traits
 
class  vector_scalar_unary
 
struct  vector_scalar_unary_traits
 
class  vector_scalar_binary
 
struct  vector_scalar_binary_traits
 
struct  vector_assign_traits
 
struct  vector_assign_traits< dense_tag, COMPUTED, packed_random_access_iterator_tag >
 
struct  vector_assign_traits< dense_tag, false, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< dense_tag, true, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< dense_proxy_tag, COMPUTED, packed_random_access_iterator_tag >
 
struct  vector_assign_traits< dense_proxy_tag, false, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< dense_proxy_tag, true, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< packed_tag, false, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< packed_tag, true, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< packed_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag >
 
struct  vector_assign_traits< sparse_tag, true, dense_random_access_iterator_tag >
 
struct  vector_assign_traits< sparse_tag, true, packed_random_access_iterator_tag >
 
struct  vector_assign_traits< sparse_tag, true, sparse_bidirectional_iterator_tag >
 
struct  vector_swap_traits
 
struct  vector_swap_traits< dense_proxy_tag, sparse_bidirectional_iterator_tag >
 
struct  vector_swap_traits< packed_proxy_tag, sparse_bidirectional_iterator_tag >
 
class  vector_matrix_binary
 
struct  vector_matrix_binary_traits
 
class  matrix_unary1
 
struct  matrix_unary1_traits
 
class  matrix_unary2
 
struct  matrix_unary2_traits
 
class  matrix_binary
 
struct  matrix_binary_traits
 
class  matrix_binary_scalar1
 
struct  matrix_binary_scalar1_traits
 
class  matrix_binary_scalar2
 
struct  matrix_binary_scalar2_traits
 
class  matrix_vector_binary1
 
struct  matrix_vector_binary1_traits
 
class  matrix_vector_binary2
 
struct  matrix_vector_binary2_traits
 
class  matrix_matrix_binary
 
struct  matrix_matrix_binary_traits
 
class  matrix_scalar_unary
 
struct  matrix_scalar_unary_traits
 
struct  matrix_assign_traits
 
struct  matrix_assign_traits< dense_tag, COMPUTED, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
 
struct  matrix_assign_traits< dense_tag, false, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_assign_traits< dense_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_assign_traits< dense_proxy_tag, COMPUTED, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
 
struct  matrix_assign_traits< dense_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_assign_traits< packed_tag, false, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_assign_traits< packed_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_assign_traits< packed_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_assign_traits< sparse_tag, true, dense_random_access_iterator_tag, dense_random_access_iterator_tag >
 
struct  matrix_assign_traits< sparse_tag, true, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
 
struct  matrix_assign_traits< sparse_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_swap_traits
 
struct  matrix_swap_traits< dense_proxy_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  matrix_swap_traits< packed_proxy_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
 
struct  vector_temporary_traits
 For the creation of temporary vectors in the assignment of proxies. More...
 
struct  matrix_temporary_traits
 For the creation of temporary vectors in the assignment of proxies. More...
 
struct  vector_temporary_traits< matrix_row< M > >
 
struct  vector_temporary_traits< const matrix_row< M > >
 
struct  vector_temporary_traits< matrix_column< M > >
 
struct  vector_temporary_traits< const matrix_column< M > >
 
struct  vector_temporary_traits< matrix_vector_range< M > >
 
struct  vector_temporary_traits< const matrix_vector_range< M > >
 
struct  vector_temporary_traits< matrix_vector_slice< M > >
 
struct  vector_temporary_traits< const matrix_vector_slice< M > >
 
struct  vector_temporary_traits< matrix_vector_indirect< M, IA > >
 
struct  vector_temporary_traits< const matrix_vector_indirect< M, IA > >
 
struct  matrix_temporary_traits< matrix_range< M > >
 
struct  matrix_temporary_traits< const matrix_range< M > >
 
struct  vector_temporary_traits< matrix_range< M > >
 
struct  vector_temporary_traits< const matrix_range< M > >
 
struct  matrix_temporary_traits< matrix_slice< M > >
 
struct  matrix_temporary_traits< const matrix_slice< M > >
 
struct  vector_temporary_traits< matrix_slice< M > >
 
struct  vector_temporary_traits< const matrix_slice< M > >
 
struct  matrix_temporary_traits< matrix_indirect< M > >
 Specialization of temporary_traits. More...
 
struct  matrix_temporary_traits< const matrix_indirect< M > >
 
struct  vector_temporary_traits< matrix_indirect< M > >
 
struct  vector_temporary_traits< const matrix_indirect< M > >
 
struct  vector_temporary_traits< vector_range< V > >
 
struct  vector_temporary_traits< const vector_range< V > >
 
struct  vector_temporary_traits< vector_slice< V > >
 
struct  vector_temporary_traits< const vector_slice< V > >
 
struct  vector_temporary_traits< vector_indirect< V > >
 
struct  vector_temporary_traits< const vector_indirect< V > >
 
struct  vector_temporary_traits< triangular_adaptor< M, TRI > >
 
struct  vector_temporary_traits< const triangular_adaptor< M, TRI > >
 
struct  matrix_temporary_traits< triangular_adaptor< M, TRI > >
 
struct  matrix_temporary_traits< const triangular_adaptor< M, TRI > >
 
struct  matrix_vector_solve_traits
 
struct  matrix_matrix_solve_traits
 
class  permutation_matrix
 
struct  vector_temporary_traits< symmetric_adaptor< M, TRI > >
 
struct  vector_temporary_traits< const symmetric_adaptor< M, TRI > >
 
struct  matrix_temporary_traits< symmetric_adaptor< M, TRI > >
 
struct  matrix_temporary_traits< const symmetric_adaptor< M, TRI > >
 

Typedefs

typedef basic_range range
 
typedef basic_slice slice
 
typedef basic_row_major row_major
 
typedef basic_column_major column_major
 
typedef basic_full full
 
typedef basic_lower lower
 
typedef basic_upper upper
 
typedef basic_unit_lower unit_lower
 
typedef basic_unit_upper unit_upper
 
typedef basic_strict_lower strict_lower
 
typedef basic_strict_upper strict_upper
 
typedef
nonassignable_::nonassignable 
nonassignable
 

Functions

template<class C >
BOOST_UBLAS_INLINE
noalias_proxy< C > 
noalias (C &lvalue)
 
template<class C >
BOOST_UBLAS_INLINE
noalias_proxy< const C > 
noalias (const C &lvalue)
 
template<class C >
BOOST_UBLAS_INLINE C & safe (C &lvalue)
 
template<class C >
BOOST_UBLAS_INLINE const C & safe (const C &lvalue)
 
template<class T1 , class T2 >
BOOST_UBLAS_INLINE T1 same_impl_ex (const T1 &size1, const T2 &size2, const char *file, int line)
 
template<class T >
BOOST_UBLAS_INLINE T same_impl_ex (const T &size1, const T &size2, const char *file, int line)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator+ (I in1, std::complex< R > const &in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator+ (std::complex< R > const &in1, I in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator- (I in1, std::complex< R > const &in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator- (std::complex< R > const &in1, I in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator* (I in1, std::complex< R > const &in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator* (std::complex< R > const &in1, I in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator/ (I in1, std::complex< R > const &in2)
 
template<typename R , typename I >
boost::enable_if< mpl::and_
< boost::is_float< R >
, boost::is_integral< I >
>, std::complex< R > >::type 
operator/ (std::complex< R > const &in1, I in2)
 
template<class I >
BOOST_UBLAS_INLINE void increment (I &it, const I &it_end, typename I::difference_type compare, packed_random_access_iterator_tag)
 
template<class I >
BOOST_UBLAS_INLINE void increment (I &it, const I &, typename I::difference_type, sparse_bidirectional_iterator_tag)
 
template<class I >
BOOST_UBLAS_INLINE void increment (I &it, const I &it_end, typename I::difference_type compare)
 
template<class I >
BOOST_UBLAS_INLINE void increment (I &it, const I &it_end)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< E,
scalar_negate< typename
E::value_type > >::result_type 
operator- (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< E,
scalar_conj< typename
E::value_type > >::result_type 
conj (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< E,
scalar_real< typename
E::value_type > >::result_type 
real (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< E,
scalar_imag< typename
E::value_type > >::result_type 
imag (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< const E,
scalar_identity< typename
E::value_type > >::result_type 
trans (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< E,
scalar_identity< typename
E::value_type > >::result_type 
trans (vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_unary_traits< E,
scalar_conj< typename
E::value_type > >::result_type 
herm (const vector_expression< E > &e)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_binary_traits< E1, E2,
scalar_plus< typename
E1::value_type, typename
E2::value_type >
>::result_type 
operator+ (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_binary_traits< E1, E2,
scalar_minus< typename
E1::value_type, typename
E2::value_type >
>::result_type 
operator- (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_binary_traits< E1, E2,
scalar_multiplies< typename
E1::value_type, typename
E2::value_type >
>::result_type 
element_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_binary_traits< E1, E2,
scalar_divides< typename
E1::value_type, typename
E2::value_type >
>::result_type 
element_div (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class T1 , class E2 >
BOOST_UBLAS_INLINE enable_if
< is_convertible< T1, typename
E2::value_type >, typename
vector_binary_scalar1_traits
< const T1, E2,
scalar_multiplies< T1,
typename E2::value_type >
>::result_type >::type 
operator* (const T1 &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class T2 >
BOOST_UBLAS_INLINE enable_if
< is_convertible< T2, typename
E1::value_type >, typename
vector_binary_scalar2_traits
< E1, const T2,
scalar_multiplies< typename
E1::value_type, T2 >
>::result_type >::type 
operator* (const vector_expression< E1 > &e1, const T2 &e2)
 
template<class E1 , class T2 >
BOOST_UBLAS_INLINE enable_if
< is_convertible< T2, typename
E1::value_type >, typename
vector_binary_scalar2_traits
< E1, const T2, scalar_divides
< typename E1::value_type, T2 >
>::result_type >::type 
operator/ (const vector_expression< E1 > &e1, const T2 &e2)
 
template<class E >
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_sum< E > >::result_type 
sum (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_norm_1< E >
>::result_type 
norm_1 (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_norm_2< E >
>::result_type 
norm_2 (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_norm_inf< E >
>::result_type 
norm_inf (const vector_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_index_norm_inf< E >
>::result_type 
index_norm_inf (const vector_expression< E > &e)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_scalar_binary_traits
< E1, E2, vector_inner_prod
< E1, E2, typename
promote_traits< typename
E1::value_type, typename
E2::value_type >::promote_type >
>::result_type 
inner_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_scalar_binary_traits
< E1, E2, vector_inner_prod
< E1, E2, typename type_traits
< typename promote_traits
< typename E1::value_type,
typename E2::value_type >
::promote_type >
::precision_type >
>::result_type 
prec_inner_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<template< class T1, class T2 > class F, class V , class T >
void iterating_vector_assign_scalar (V &v, const T &t)
 
template<template< class T1, class T2 > class F, class V , class T >
void indexing_vector_assign_scalar (V &v, const T &t)
 
template<template< class T1, class T2 > class F, class V , class T >
void vector_assign_scalar (V &v, const T &t, dense_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class T >
void vector_assign_scalar (V &v, const T &t, packed_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class T >
void vector_assign_scalar (V &v, const T &t, sparse_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class T >
BOOST_UBLAS_INLINE void vector_assign_scalar (V &v, const T &t)
 
template<template< class T1, class T2 > class F, class V , class E >
void iterating_vector_assign (V &v, const vector_expression< E > &e)
 
template<template< class T1, class T2 > class F, class V , class E >
void indexing_vector_assign (V &v, const vector_expression< E > &e)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_assign (V &v, const vector_expression< E > &e, dense_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_assign (V &v, const vector_expression< E > &e, packed_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_assign (V &v, const vector_expression< E > &e, sparse_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_assign (V &v, const vector_expression< E > &e, sparse_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
BOOST_UBLAS_INLINE void vector_assign (V &v, const vector_expression< E > &e)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_swap (V &v, vector_expression< E > &e, dense_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_swap (V &v, vector_expression< E > &e, packed_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
void vector_swap (V &v, vector_expression< E > &e, sparse_proxy_tag)
 
template<template< class T1, class T2 > class F, class V , class E >
BOOST_UBLAS_INLINE void vector_swap (V &v, vector_expression< E > &e)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
vector_matrix_binary_traits
< E1, E2, scalar_multiplies
< typename E1::value_type,
typename E2::value_type >
>::result_type 
outer_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary1_traits< E,
scalar_negate< typename
E::value_type > >::result_type 
operator- (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary1_traits< E,
scalar_conj< typename
E::value_type > >::result_type 
conj (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary1_traits< E,
scalar_real< typename
E::value_type > >::result_type 
real (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary1_traits< E,
scalar_imag< typename
E::value_type > >::result_type 
imag (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary2_traits< const E,
scalar_identity< typename
E::value_type > >::result_type 
trans (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary2_traits< E,
scalar_identity< typename
E::value_type > >::result_type 
trans (matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE
matrix_unary2_traits< E,
scalar_conj< typename
E::value_type > >::result_type 
herm (const matrix_expression< E > &e)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
matrix_binary_traits< E1, E2,
scalar_plus< typename
E1::value_type, typename
E2::value_type >
>::result_type 
operator+ (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
matrix_binary_traits< E1, E2,
scalar_minus< typename
E1::value_type, typename
E2::value_type >
>::result_type 
operator- (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
matrix_binary_traits< E1, E2,
scalar_multiplies< typename
E1::value_type, typename
E2::value_type >
>::result_type 
element_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE
matrix_binary_traits< E1, E2,
scalar_divides< typename
E1::value_type, typename
E2::value_type >
>::result_type 
element_div (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class T1 , class E2 >
BOOST_UBLAS_INLINE enable_if
< is_convertible< T1, typename
E2::value_type >, typename
matrix_binary_scalar1_traits
< const T1, E2,
scalar_multiplies< T1,
typename E2::value_type >
>::result_type >::type 
operator* (const T1 &e1, const matrix_expression< E2 > &e2)
 
template<class E1 , class T2 >
BOOST_UBLAS_INLINE enable_if
< is_convertible< T2, typename
E1::value_type >, typename
matrix_binary_scalar2_traits
< E1, const T2,
scalar_multiplies< typename
E1::value_type, T2 >
>::result_type >::type 
operator* (const matrix_expression< E1 > &e1, const T2 &e2)
 
template<class E1 , class T2 >
BOOST_UBLAS_INLINE
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<template< class T1, class T2 > class F, class M , class T >
void iterating_matrix_assign_scalar (M &m, const T &t, row_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
void iterating_matrix_assign_scalar (M &m, const T &t, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
void indexing_matrix_assign_scalar (M &m, const T &t, row_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
void indexing_matrix_assign_scalar (M &m, const T &t, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T , class C >
void matrix_assign_scalar (M &m, const T &t, dense_proxy_tag, C)
 
template<template< class T1, class T2 > class F, class M , class T >
void matrix_assign_scalar (M &m, const T &t, packed_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
void matrix_assign_scalar (M &m, const T &t, packed_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
void matrix_assign_scalar (M &m, const T &t, sparse_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
void matrix_assign_scalar (M &m, const T &t, sparse_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class T >
BOOST_UBLAS_INLINE void matrix_assign_scalar (M &m, const T &t)
 
template<template< class T1, class T2 > class F, class M , class E >
void iterating_matrix_assign (M &m, const matrix_expression< E > &e, row_major_tag)
 
template<template< class T1, class T2 > class F, class M , class E >
void iterating_matrix_assign (M &m, const matrix_expression< E > &e, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class E >
void indexing_matrix_assign (M &m, const matrix_expression< E > &e, row_major_tag)
 
template<template< class T1, class T2 > class F, class M , class E >
void indexing_matrix_assign (M &m, const matrix_expression< E > &e, column_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E , class C >
void matrix_assign (M &m, const matrix_expression< E > &e, dense_proxy_tag, C)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_assign (M &m, const matrix_expression< E > &e, packed_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_assign (M &m, const matrix_expression< E > &e, packed_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_assign (M &m, const matrix_expression< E > &e, sparse_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_assign (M &m, const matrix_expression< E > &e, sparse_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_assign (M &m, const matrix_expression< E > &e, sparse_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_assign (M &m, const matrix_expression< E > &e, sparse_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class E >
BOOST_UBLAS_INLINE void matrix_assign (M &m, const matrix_expression< E > &e)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
BOOST_UBLAS_INLINE void matrix_assign (M &m, const matrix_expression< E > &e)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_swap (M &m, matrix_expression< E > &e, dense_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_swap (M &m, matrix_expression< E > &e, dense_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_swap (M &m, matrix_expression< E > &e, packed_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_swap (M &m, matrix_expression< E > &e, packed_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_swap (M &m, matrix_expression< E > &e, sparse_proxy_tag, row_major_tag)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
void matrix_swap (M &m, matrix_expression< E > &e, sparse_proxy_tag, column_major_tag)
 
template<template< class T1, class T2 > class F, class M , class E >
BOOST_UBLAS_INLINE void matrix_swap (M &m, matrix_expression< E > &e)
 
template<template< class T1, class T2 > class F, class R , class M , class E >
BOOST_UBLAS_INLINE void matrix_swap (M &m, matrix_expression< E > &e)
 
template<class M >
BOOST_UBLAS_INLINE matrix_row< M > row (M &data, typename M::size_type i)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_row< const M > 
row (const M &data, typename M::size_type i)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_column< M > 
column (M &data, typename M::size_type j)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_column< const M > 
column (const M &data, typename M::size_type j)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_range< M > 
subrange (M &data, typename M::size_type start1, typename M::size_type stop1, typename M::size_type start2, typename M::size_type stop2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_range< const M > 
subrange (const M &data, typename M::size_type start1, typename M::size_type stop1, typename M::size_type start2, typename M::size_type stop2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_range< M > 
project (M &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_range< const M > 
project (const M &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_range< M > 
project (matrix_range< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_range< M > 
project (const matrix_range< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_slice< M > 
subslice (M &data, typename M::size_type start1, typename M::difference_type stride1, typename M::size_type size1, typename M::size_type start2, typename M::difference_type stride2, typename M::size_type size2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_slice< const M > 
subslice (const M &data, typename M::size_type start1, typename M::difference_type stride1, typename M::size_type size1, typename M::size_type start2, typename M::difference_type stride2, typename M::size_type size2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_slice< M > 
project (M &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_slice< const M > 
project (const M &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_slice< M > 
project (matrix_slice< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_slice< M > 
project (const matrix_slice< M > &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
 
template<class M >
BOOST_UBLAS_INLINE
matrix_slice< M > 
project (matrix_slice< M > &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2)
 
template<class M >
BOOST_UBLAS_INLINE const
matrix_slice< M > 
project (const matrix_slice< M > &data, const typename matrix_slice< M >::slice_type &s1, const typename matrix_slice< M >::slice_type &s2)
 
template<class M , class A >
BOOST_UBLAS_INLINE
matrix_indirect< M,
indirect_array< A > > 
project (M &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2)
 
template<class M , class A >
BOOST_UBLAS_INLINE const
matrix_indirect< const M,
indirect_array< A > > 
project (const M &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2)
 
template<class M , class IA >
BOOST_UBLAS_INLINE
matrix_indirect< M, IA > 
project (matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::range_type &r1, const typename matrix_indirect< M, IA >::range_type &r2)
 
template<class M , class IA >
BOOST_UBLAS_INLINE const
matrix_indirect< M, IA > 
project (const matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::range_type &r1, const typename matrix_indirect< M, IA >::range_type &r2)
 
template<class M , class IA >
BOOST_UBLAS_INLINE
matrix_indirect< M, IA > 
project (matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::slice_type &s1, const typename matrix_indirect< M, IA >::slice_type &s2)
 
template<class M , class IA >
BOOST_UBLAS_INLINE const
matrix_indirect< M, IA > 
project (const matrix_indirect< M, IA > &data, const typename matrix_indirect< M, IA >::slice_type &s1, const typename matrix_indirect< M, IA >::slice_type &s2)
 
template<class M , class A >
BOOST_UBLAS_INLINE
matrix_indirect< M,
indirect_array< A > > 
project (matrix_indirect< M, indirect_array< A > > &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2)
 
template<class M , class A >
BOOST_UBLAS_INLINE const
matrix_indirect< M,
indirect_array< A > > 
project (const matrix_indirect< M, indirect_array< A > > &data, const indirect_array< A > &ia1, const indirect_array< A > &ia2)
 
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, row_major_tag)
 
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, column_major_tag)
 
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true)
 
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >
BOOST_UBLAS_INLINE V axpy_prod (const compressed_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2)
 
template<class V , class T1 , class L1 , class IA1 , class TA1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const coordinate_matrix< T1, L1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, row_major_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, column_major_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, sparse_bidirectional_iterator_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, packed_random_access_iterator_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true)
 computes v += A x or v = A x in an optimized fashion. More...
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class V , class E1 , class T2 , class IA2 , class TA2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, column_major, 0, IA2, TA2 > &e2, V &v, column_major_tag)
 
template<class V , class E1 , class T2 , class IA2 , class TA2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, row_major, 0, IA2, TA2 > &e2, V &v, row_major_tag)
 
template<class V , class E1 , class T2 , class L2 , class IA2 , class TA2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, L2, 0, IA2, TA2 > &e2, V &v, bool init=true)
 
template<class V , class E1 , class T2 , class L2 , class IA2 , class TA2 >
BOOST_UBLAS_INLINE V axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, L2, 0, IA2, TA2 > &e2)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, column_major_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, packed_random_access_iterator_tag, row_major_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, sparse_bidirectional_iterator_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, packed_random_access_iterator_tag)
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v, bool init=true)
 computes v += AT x or v = AT x in an optimized fashion. More...
 
template<class V , class E1 , class E2 >
BOOST_UBLAS_INLINE V axpy_prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, dense_proxy_tag, row_major_tag)
 
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, sparse_proxy_tag, row_major_tag)
 
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, dense_proxy_tag, column_major_tag)
 
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, sparse_proxy_tag, column_major_tag)
 
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, TRI, bool init=true)
 
template<class M , class E1 , class E2 , class TRI >
BOOST_UBLAS_INLINE M axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, TRI)
 
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, bool init=true)
 computes M += A X or M = A X in an optimized fashion. More...
 
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M & opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, dense_proxy_tag, row_major_tag)
 
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M & opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, dense_proxy_tag, column_major_tag)
 
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M & opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, bool init=true)
 computes M += A X or M = A X in an optimized fashion. More...
 
template<class M , class E1 , class E2 >
BOOST_UBLAS_INLINE M opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class V >
BOOST_UBLAS_INLINE
vector_range< V > 
subrange (V &data, typename V::size_type start, typename V::size_type stop)
 Return a vector_range on a specified vector, a start and stop index. Return a vector_range on a specified vector, a start and stop index. The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined.
 
template<class V >
BOOST_UBLAS_INLINE
vector_range< const V > 
subrange (const V &data, typename V::size_type start, typename V::size_type stop)
 Return a const vector_range on a specified vector, a start and stop index. Return a const vector_range on a specified vector, a start and stop index. The resulting const vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined.
 
template<class V >
BOOST_UBLAS_INLINE
vector_range< V > 
project (V &data, typename vector_range< V >::range_type const &r)
 Return a const vector_range on a specified vector and range Return a const vector_range on a specified vector and range. The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined.
 
template<class V >
BOOST_UBLAS_INLINE const
vector_range< const V > 
project (const V &data, typename vector_range< V >::range_type const &r)
 Return a vector_range on a specified vector and range Return a vector_range on a specified vector and range. The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined.
 
template<class V >
BOOST_UBLAS_INLINE
vector_range< V > 
project (vector_range< V > &data, const typename vector_range< V >::range_type &r)
 Return a const vector_range on a specified vector and const range Return a const vector_range on a specified vector and const range. The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined.
 
template<class V >
BOOST_UBLAS_INLINE const
vector_range< V > 
project (const vector_range< V > &data, const typename vector_range< V >::range_type &r)
 Return a vector_range on a specified vector and const range Return a vector_range on a specified vector and const range. The resulting vector_range can be manipulated like a normal vector. If the specified range falls outside that of of the index range of the vector, then the resulting vector_range is not a well formed Vector Expression and access to an element outside of index range of the vector is undefined.
 
template<class V >
BOOST_UBLAS_INLINE
vector_slice< V > 
subslice (V &data, typename V::size_type start, typename V::difference_type stride, typename V::size_type size)
 
template<class V >
BOOST_UBLAS_INLINE
vector_slice< const V > 
subslice (const V &data, typename V::size_type start, typename V::difference_type stride, typename V::size_type size)
 
template<class V >
BOOST_UBLAS_INLINE
vector_slice< V > 
project (V &data, const typename vector_slice< V >::slice_type &s)
 
template<class V >
BOOST_UBLAS_INLINE const
vector_slice< const V > 
project (const V &data, const typename vector_slice< V >::slice_type &s)
 
template<class V >
BOOST_UBLAS_INLINE
vector_slice< V > 
project (vector_slice< V > &data, const typename vector_slice< V >::slice_type &s)
 
template<class V >
BOOST_UBLAS_INLINE const
vector_slice< V > 
project (const vector_slice< V > &data, const typename vector_slice< V >::slice_type &s)
 
template<class V >
BOOST_UBLAS_INLINE
vector_slice< V > 
project (vector_slice< V > &data, const typename vector_range< V >::range_type &r)
 
template<class V >
BOOST_UBLAS_INLINE const
vector_slice< V > 
project (const vector_slice< V > &data, const typename vector_range< V >::range_type &r)
 
template<class V , class A >
BOOST_UBLAS_INLINE
vector_indirect< V,
indirect_array< A > > 
project (V &data, const indirect_array< A > &ia)
 
template<class V , class A >
BOOST_UBLAS_INLINE const
vector_indirect< const V,
indirect_array< A > > 
project (const V &data, const indirect_array< A > &ia)
 
template<class V , class IA >
BOOST_UBLAS_INLINE
vector_indirect< V, IA > 
project (vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::range_type &r)
 
template<class V , class IA >
BOOST_UBLAS_INLINE const
vector_indirect< V, IA > 
project (const vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::range_type &r)
 
template<class V , class IA >
BOOST_UBLAS_INLINE
vector_indirect< V, IA > 
project (vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::slice_type &s)
 
template<class V , class IA >
BOOST_UBLAS_INLINE const
vector_indirect< V, IA > 
project (const vector_indirect< V, IA > &data, const typename vector_indirect< V, IA >::slice_type &s)
 
template<class V , class A >
BOOST_UBLAS_INLINE
vector_indirect< V,
indirect_array< A > > 
project (vector_indirect< V, indirect_array< A > > &data, const indirect_array< A > &ia)
 
template<class V , class A >
BOOST_UBLAS_INLINE const
vector_indirect< V,
indirect_array< A > > 
project (const vector_indirect< V, indirect_array< A > > &data, const indirect_array< A > &ia)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag, dense_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag, packed_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag, unknown_storage_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag, dense_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag, packed_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag, unknown_storage_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, column_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag, row_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, lower_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, unit_lower_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag, dense_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag, packed_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag, unknown_storage_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag, dense_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag, packed_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag, unknown_storage_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, column_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag, row_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, upper_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, vector_expression< E2 > &e2, unit_upper_tag)
 
template<class E1 , class E2 , class C >
BOOST_UBLAS_INLINE
matrix_vector_solve_traits< E1,
E2 >::result_type 
solve (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, C)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, lower_tag, row_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, lower_tag, column_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, lower_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, unit_lower_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, upper_tag, row_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, upper_tag, column_major_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, upper_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, unit_upper_tag)
 
template<class E1 , class E2 , class C >
BOOST_UBLAS_INLINE
matrix_vector_solve_traits< E1,
E2 >::result_type 
solve (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, C)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag, dense_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag, packed_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag, unknown_storage_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, lower_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, unit_lower_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag, dense_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag, packed_proxy_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag, unknown_storage_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, upper_tag)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, unit_upper_tag)
 
template<class E1 , class E2 , class C >
BOOST_UBLAS_INLINE
matrix_matrix_solve_traits< E1,
E2 >::result_type 
solve (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, C)
 
template<class PM , class MV >
BOOST_UBLAS_INLINE void swap_rows (const PM &pm, MV &mv, vector_tag)
 
template<class PM , class MV >
BOOST_UBLAS_INLINE void swap_rows (const PM &pm, MV &mv, matrix_tag)
 
template<class PM , class MV >
BOOST_UBLAS_INLINE void swap_rows (const PM &pm, MV &mv)
 
template<class M >
M::size_type lu_factorize (M &m)
 
template<class M , class PM >
M::size_type lu_factorize (M &m, PM &pm)
 
template<class M , class PM >
M::size_type axpy_lu_factorize (M &m, PM &pm)
 
template<class M , class E >
void lu_substitute (const M &m, vector_expression< E > &e)
 
template<class M , class E >
void lu_substitute (const M &m, matrix_expression< E > &e)
 
template<class M , class PMT , class PMA , class MV >
void lu_substitute (const M &m, const permutation_matrix< PMT, PMA > &pm, MV &mv)
 
template<class E , class M >
void lu_substitute (vector_expression< E > &e, const M &m)
 
template<class E , class M >
void lu_substitute (matrix_expression< E > &e, const M &m)
 
template<class MV , class M , class PMT , class PMA >
void lu_substitute (MV &mv, const M &m, const permutation_matrix< PMT, PMA > &pm)
 
template<class M >
bool is_symmetric (const M &m)
 
template<class E , class T , class VE >
std::basic_ostream< E, T > & operator<< (std::basic_ostream< E, T > &os, const vector_expression< VE > &v)
 output stream operator for vector expressions More...
 
template<class E , class T , class VT , class VA >
std::basic_istream< E, T > & operator>> (std::basic_istream< E, T > &is, vector< VT, VA > &v)
 input stream operator for vectors More...
 
template<class E , class T , class ME >
std::basic_ostream< E, T > & operator<< (std::basic_ostream< E, T > &os, const matrix_expression< ME > &m)
 output stream operator for matrix expressions More...
 
template<class E , class T , class MT , class MF , class MA >
std::basic_istream< E, T > & operator>> (std::basic_istream< E, T > &is, matrix< MT, MF, MA > &m)
 input stream operator for matrices More...
 
template<class E , class T , class MT , class MF1 , class MF2 , class MA >
std::basic_istream< E, T > & operator>> (std::basic_istream< E, T > &is, symmetric_matrix< MT, MF1, MF2, MA > &m)
 special input stream operator for symmetric matrices More...
 

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