Logo Search packages:      
Sourcecode: boost version File versions

boost::numeric::ublas Namespace Reference


Detailed Description

contains all important classes and functions of uBLAS

all ublas definitions ...

Todo:
expand this section


Classes

struct  abstract_tag
struct  AdditiveAbelianGroupConcept
class  array_adaptor
struct  assign_tag
struct  AssignableConcept
struct  bad_argument
struct  bad_index
struct  bad_size
class  banded_adaptor
class  banded_matrix
class  basic_range
class  basic_slice
struct  bidirectional_iterator_base
 Base class of all bidirectional iterators. More...
struct  BidirectionalIteratorConcept
class  bounded_array
class  bounded_matrix
class  bounded_vector
class  c_matrix
class  c_vector
struct  column_major
struct  column_major_tag
struct  CommutativeRingWithIdentityConcept
class  compressed_matrix
class  compressed_vector
struct  computed_assign_tag
struct  concrete_tag
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  ContainerConcept
class  coordinate_matrix
class  coordinate_vector
struct  DefaultConstructibleConcept
struct  dense_proxy_tag
struct  dense_random_access_iterator_tag
struct  dense_tag
class  diagonal_adaptor
class  diagonal_matrix
struct  divide_by_zero
struct  EqualityComparableConcept
struct  error_cant_deduce_type
struct  external_logic
struct  FieldConcept
struct  forward_iterator_base
 Base class of all forward iterators. More...
struct  full
class  hermitian_adaptor
class  hermitian_matrix
class  identity_matrix
class  index_pair
class  index_pair_array
class  index_triple
class  index_triple_array
struct  Indexed1DIteratorConcept
struct  Indexed2DIteratorConcept
class  indexed_const_iterator
 A class implementing an indexed random access iterator. More...
class  indexed_const_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_iterator
 A class implementing an indexed random access iterator. More...
class  indexed_iterator1
 A class implementing an indexed random access iterator of a matrix. More...
class  indexed_iterator2
 A class implementing an indexed random access iterator of a matrix. More...
struct  IndexedBidirectional1DIteratorConcept
struct  IndexedBidirectional2DIteratorConcept
struct  IndexedRandomAccess1DIteratorConcept
struct  IndexedRandomAccess2DIteratorConcept
struct  IndexSetConcept
class  indirect_array
struct  internal_logic
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  LessThanComparableConcept
struct  LinearOperatorConcept
struct  lower
struct  lower_tag
class  map_array
class  map_std
class  matrix
struct  matrix_assign_traits
struct  matrix_assign_traits< dense_proxy_tag, assign_tag, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
struct  matrix_assign_traits< dense_proxy_tag, assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< dense_proxy_tag, computed_assign_tag, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
struct  matrix_assign_traits< dense_proxy_tag, computed_assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< dense_tag, assign_tag, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
struct  matrix_assign_traits< dense_tag, assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< dense_tag, computed_assign_tag, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
struct  matrix_assign_traits< dense_tag, computed_assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< packed_proxy_tag, assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< packed_proxy_tag, computed_assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< packed_tag, assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< packed_tag, computed_assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
struct  matrix_assign_traits< sparse_tag, computed_assign_tag, dense_random_access_iterator_tag, dense_random_access_iterator_tag >
struct  matrix_assign_traits< sparse_tag, computed_assign_tag, packed_random_access_iterator_tag, packed_random_access_iterator_tag >
struct  matrix_assign_traits< sparse_tag, computed_assign_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag >
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_expression
class  matrix_indirect
class  matrix_matrix_binary
struct  matrix_matrix_binary_functor
struct  matrix_matrix_binary_traits
struct  matrix_matrix_prod
struct  matrix_matrix_solve_traits
struct  matrix_norm_1
struct  matrix_norm_frobenius
struct  matrix_norm_inf
class  matrix_range
class  matrix_reference
class  matrix_row
struct  matrix_scalar_real_unary_functor
class  matrix_scalar_unary
struct  matrix_scalar_unary_traits
class  matrix_slice
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  matrix_tag
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  MatrixConcept
struct  MatrixExpressionConcept
struct  MultiplicativeAbelianGroupConcept
struct  MutableBidirectionalIteratorConcept
struct  MutableContainerConcept
struct  MutableIndexedBidirectional1DIteratorConcept
struct  MutableIndexedBidirectional2DIteratorConcept
struct  MutableIndexedRandomAccess1DIteratorConcept
struct  MutableIndexedRandomAccess2DIteratorConcept
struct  MutableMatrixConcept
struct  MutableMatrixExpressionConcept
struct  MutableRandomAccessContainerConcept
struct  MutableRandomAccessIteratorConcept
struct  MutableReversibleContainerConcept
struct  MutableStorageArrayConcept
struct  MutableStorageSparseConcept
struct  MutableVectorConcept
struct  MutableVectorExpressionConcept
class  noalias_proxy
struct  non_real
struct  packed_proxy_tag
struct  packed_random_access_iterator_tag
struct  packed_tag
class  permutation_matrix
struct  promote_traits
struct  promote_type_multiplies
struct  random_access_iterator_base
 Base class of all random access iterators. More...
struct  RandomAccessContainerConcept
struct  RandomAccessIteratorConcept
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...
struct  ReversibleContainerConcept
struct  RingWithIdentityConcept
struct  row_major
struct  row_major_tag
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
struct  scalar_identity
struct  scalar_imag
class  scalar_matrix
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_unary_functor
class  scalar_value
class  scalar_vector
struct  ScalarExpressionConcept
struct  singular
struct  sparse_bidirectional_iterator_tag
class  sparse_matrix
struct  sparse_proxy_tag
struct  sparse_tag
class  sparse_vector
class  sparse_vector_of_sparse_vector
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  StorageArrayConcept
struct  StorageSparseConcept
struct  strict_lower
struct  strict_upper
class  symmetric_adaptor
class  symmetric_matrix
class  triangular_adaptor
class  triangular_matrix
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
class  unbounded_array
struct  unit_lower
struct  unit_lower_tag
struct  unit_upper
struct  unit_upper_tag
class  unit_vector
struct  unknown_orientation_tag
struct  unknown_storage_tag
struct  upper
struct  upper_tag
class  vector
struct  vector_assign_traits
struct  vector_assign_traits< dense_proxy_tag, assign_tag, packed_random_access_iterator_tag >
struct  vector_assign_traits< dense_proxy_tag, assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< dense_proxy_tag, computed_assign_tag, packed_random_access_iterator_tag >
struct  vector_assign_traits< dense_proxy_tag, computed_assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< dense_tag, assign_tag, packed_random_access_iterator_tag >
struct  vector_assign_traits< dense_tag, assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< dense_tag, computed_assign_tag, packed_random_access_iterator_tag >
struct  vector_assign_traits< dense_tag, computed_assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< packed_proxy_tag, assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< packed_proxy_tag, computed_assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< packed_tag, assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< packed_tag, computed_assign_tag, sparse_bidirectional_iterator_tag >
struct  vector_assign_traits< sparse_tag, computed_assign_tag, dense_random_access_iterator_tag >
struct  vector_assign_traits< sparse_tag, computed_assign_tag, packed_random_access_iterator_tag >
struct  vector_assign_traits< sparse_tag, computed_assign_tag, sparse_bidirectional_iterator_tag >
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
class  vector_expression
struct  vector_index_norm_inf
class  vector_indirect
struct  vector_inner_prod
class  vector_matrix_binary
struct  vector_matrix_binary_traits
struct  vector_norm_1
struct  vector_norm_2
struct  vector_norm_inf
class  vector_of_vector
class  vector_range
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
struct  vector_sum
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 >
struct  vector_tag
class  vector_unary
struct  vector_unary_traits
struct  VectorConcept
struct  VectorExpressionConcept
struct  VectorSpaceConcept
class  zero_matrix
class  zero_vector

Namespaces

namespace  blas_1
 wrapper functions for level 1 blas
namespace  blas_2
 wrapper functions for level 2 blas
namespace  blas_3
 wrapper functions for level 3 blas

Typedefs

typedef
nonassignable_::nonassignable 
nonassignable
typedef basic_range range
typedef basic_slice slice

Functions

template<class M, class PM>
M::size_type axpy_lu_factorize (M &m, PM &pm)
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 & 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.
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, F)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, bool init=true)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, sparse_proxy_tag, column_major_tag)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, dense_proxy_tag, column_major_tag)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, sparse_proxy_tag, row_major_tag)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & axpy_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, dense_proxy_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)
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.
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, 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, 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, packed_random_access_iterator_tag, column_major_tag)
template<class V, class E1, class T2, class F2, class IA2, class TA2>
BOOST_UBLAS_INLINE V axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, F2, 0, IA2, TA2 > &e2)
template<class V, class E1, class T2, class F2, class IA2, class TA2>
BOOST_UBLAS_INLINE V & axpy_prod (const vector_expression< E1 > &e1, const compressed_matrix< T2, F2, 0, IA2, TA2 > &e2, V &v, bool init=true)
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 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 E2>
BOOST_UBLAS_INLINE V axpy_prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2)
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.
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, 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, 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, packed_random_access_iterator_tag, row_major_tag)
template<class V, class T1, class F, class IA1, class TA1, class E2>
BOOST_UBLAS_INLINE V axpy_prod (const compressed_matrix< T1, F, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2)
template<class V, class T1, class F1, class IA1, class TA1, class E2>
BOOST_UBLAS_INLINE V & axpy_prod (const compressed_matrix< T1, F1, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, bool init=true)
template<class V, class T1, class IA1, class TA1, class E2>
BOOST_UBLAS_INLINE V & axpy_prod (const compressed_matrix< T1, column_major, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, column_major_tag)
template<class V, class T1, class IA1, class TA1, class E2>
BOOST_UBLAS_INLINE V & axpy_prod (const compressed_matrix< T1, row_major, 0, IA1, TA1 > &e1, const vector_expression< E2 > &e2, V &v, 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)
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, row_major_tag)
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 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 M>
BOOST_UBLAS_INLINE
matrix_column< M > 
column (const M &data, typename M::size_type j)
template<class M>
BOOST_UBLAS_INLINE
matrix_column< M > 
column (M &data, typename M::size_type j)
template<class M>
BOOST_UBLAS_INLINE
matrix_column< const M > 
column_const (const M &data, typename M::size_type j)
void concept_checks ()
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
matrix_unary1_traits< E,
scalar_conj< typename
E::value_type > >::result_type 
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 
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 
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 
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 
element_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
template<class E1, class E2>
BOOST_UBLAS_INLINE bool equals (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
template<class E1, class E2>
BOOST_UBLAS_INLINE bool equals (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
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 E>
BOOST_UBLAS_INLINE
matrix_unary2_traits< E,
scalar_conj< typename
E::value_type > >::result_type 
herm (const matrix_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
matrix_unary1_traits< E,
scalar_imag< typename
E::value_type > >::result_type 
imag (const matrix_expression< E > &e)
template<class I>
BOOST_UBLAS_INLINE void increment (I &it, const I &it_end)
template<class I>
BOOST_UBLAS_INLINE void increment (I &it, const I &it_end, BOOST_UBLAS_TYPENAME I::difference_type compare)
template<class I>
BOOST_UBLAS_INLINE void increment (I &it, const I &, BOOST_UBLAS_TYPENAME I::difference_type, sparse_bidirectional_iterator_tag)
template<class I>
BOOST_UBLAS_INLINE void increment (I &it, const I &it_end, BOOST_UBLAS_TYPENAME I::difference_type compare, packed_random_access_iterator_tag)
template<class E>
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_index_norm_inf
< typename E::value_type >
>::result_type 
index_norm_inf (const vector_expression< E > &e)
template<class F, class M, class E>
void indexing_matrix_assign (F, M &m, const matrix_expression< E > &e, column_major_tag)
template<class F, class M, class E>
void indexing_matrix_assign (F, M &m, const matrix_expression< E > &e, row_major_tag)
template<class F, class M, class T>
void indexing_matrix_assign_scalar (F, M &m, const T &t, column_major_tag)
template<class F, class M, class T>
void indexing_matrix_assign_scalar (F, M &m, const T &t, row_major_tag)
template<class F, class V, class E>
void indexing_vector_assign (F, V &v, const vector_expression< E > &e)
template<class F, class V, class T>
void indexing_vector_assign_scalar (F, V &v, const T &t)
template<class E1, class E2>
BOOST_UBLAS_INLINE
vector_scalar_binary_traits
< E1, E2, vector_inner_prod
< typename E1::value_type,
typename E2::value_type,
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 void inplace_solve (const matrix_expression< E1 > &e1, matrix_expression< E2 > &e2, unit_upper_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, 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, 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, dense_proxy_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, lower_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, 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, dense_proxy_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>
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, 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, 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, row_major_tag, unknown_storage_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, packed_proxy_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, dense_proxy_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, lower_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, 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, row_major_tag, unknown_storage_tag)
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, packed_proxy_tag)
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, dense_proxy_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>
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, 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, 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, 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, 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, dense_proxy_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, lower_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, 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, 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, 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, dense_proxy_tag)
template<class M>
bool is_hermitian (const M &m)
template<class M>
bool is_symmetric (const M &m)
template<class F, class M, class E>
void iterating_matrix_assign (F, M &m, const matrix_expression< E > &e, column_major_tag)
template<class F, class M, class E>
void iterating_matrix_assign (F, M &m, const matrix_expression< E > &e, row_major_tag)
template<class F, class M, class T>
void iterating_matrix_assign_scalar (F, M &m, const T &t, column_major_tag)
template<class F, class M, class T>
void iterating_matrix_assign_scalar (F, M &m, const T &t, row_major_tag)
template<class F, class V, class E>
void iterating_vector_assign (F, V &v, const vector_expression< E > &e)
template<class F, class V, class T>
void iterating_vector_assign_scalar (F, V &v, const T &t)
template<class M, class PM>
M::size_type lu_factorize (M &m, PM &pm)
template<class M>
M::size_type lu_factorize (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 E, class M>
void lu_substitute (matrix_expression< E > &e, const M &m)
template<class E, class M>
void lu_substitute (vector_expression< E > &e, const M &m)
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 M, class E>
void lu_substitute (const M &m, matrix_expression< E > &e)
template<class M, class E>
void lu_substitute (const M &m, vector_expression< E > &e)
template<class V, class E>
void make_conformant (V &v, const vector_expression< E > &e)
template<class M, class E, class F>
void make_conformant (M &m, const matrix_expression< E > &e, column_major_tag, F)
template<class M, class E, class F>
void make_conformant (M &m, const matrix_expression< E > &e, row_major_tag, F)
template<class F1, class F2, class M, class E>
BOOST_UBLAS_INLINE void matrix_assign (F1, F2, M &m, const matrix_expression< E > &e)
template<class F, class M, class E>
BOOST_UBLAS_INLINE void matrix_assign (F, M &m, const matrix_expression< E > &e)
template<class F1, class F2, class M, class E>
void matrix_assign (F1, F2, M &m, const matrix_expression< E > &e, sparse_proxy_tag, column_major_tag)
template<class F1, class F2, class M, class E>
void matrix_assign (F1, F2, M &m, const matrix_expression< E > &e, sparse_proxy_tag, row_major_tag)
template<class VT, class M, class E>
void matrix_assign (scalar_assign< BOOST_UBLAS_TYPENAME M::reference, VT >, full, M &m, const matrix_expression< E > &e, sparse_tag, column_major_tag)
template<class VT, class M, class E>
void matrix_assign (scalar_assign< BOOST_UBLAS_TYPENAME M::reference, VT >, full, M &m, const matrix_expression< E > &e, sparse_tag, row_major_tag)
template<class F1, class F2, class M, class E>
void matrix_assign (F1, F2, M &m, const matrix_expression< E > &e, packed_proxy_tag, column_major_tag)
template<class F1, class F2, class M, class E>
void matrix_assign (F1, F2, M &m, const matrix_expression< E > &e, packed_proxy_tag, row_major_tag)
template<class F, class M, class E, class C>
void matrix_assign (F, full, M &m, const matrix_expression< E > &e, dense_proxy_tag, C)
template<class F, class M, class T>
BOOST_UBLAS_INLINE void matrix_assign_scalar (F, M &m, const T &t)
template<class F, class M, class T>
void matrix_assign_scalar (F, M &m, const T &t, sparse_proxy_tag, column_major_tag)
template<class F, class M, class T>
void matrix_assign_scalar (F, M &m, const T &t, sparse_proxy_tag, row_major_tag)
template<class F, class M, class T>
void matrix_assign_scalar (F, M &m, const T &t, packed_proxy_tag, column_major_tag)
template<class F, class M, class T>
void matrix_assign_scalar (F, M &m, const T &t, packed_proxy_tag, row_major_tag)
template<class F, class M, class T, class C>
void matrix_assign_scalar (F, M &m, const T &t, dense_proxy_tag, C)
template<class F1, class F2, class M, class E>
BOOST_UBLAS_INLINE void matrix_swap (F1, F2, M &m, matrix_expression< E > &e)
template<class F, class M, class E>
BOOST_UBLAS_INLINE void matrix_swap (F, M &m, matrix_expression< E > &e)
template<class F1, class F2, class M, class E>
void matrix_swap (F1, F2, M &m, matrix_expression< E > &e, sparse_proxy_tag, column_major_tag)
template<class F1, class F2, class M, class E>
void matrix_swap (F1, F2, M &m, matrix_expression< E > &e, sparse_proxy_tag, row_major_tag)
template<class F1, class F2, class M, class E>
void matrix_swap (F1, F2, M &m, matrix_expression< E > &e, packed_proxy_tag, column_major_tag)
template<class F1, class F2, class M, class E>
void matrix_swap (F1, F2, M &m, matrix_expression< E > &e, packed_proxy_tag, row_major_tag)
template<class F, class M, class E>
void matrix_swap (F, full, M &m, matrix_expression< E > &e, dense_proxy_tag, column_major_tag)
template<class F, class M, class E>
void matrix_swap (F, full, M &m, matrix_expression< E > &e, dense_proxy_tag, row_major_tag)
template<class C>
BOOST_UBLAS_INLINE
noalias_proxy< const C > 
noalias (const C &lvalue)
template<class C>
BOOST_UBLAS_INLINE
noalias_proxy< C > 
noalias (C &lvalue)
template<class E>
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_norm_1< typename
E::value_type > >::result_type 
norm_1 (const vector_expression< E > &e)
template<class E>
BOOST_UBLAS_INLINE
matrix_scalar_unary_traits< E,
matrix_norm_1< typename
E::value_type > >::result_type 
norm_1 (const matrix_expression< E > &e)
template<class E>
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_norm_2< typename
E::value_type > >::result_type 
norm_2 (const vector_expression< E > &e)
template<class E>
BOOST_UBLAS_INLINE
matrix_scalar_unary_traits< E,
matrix_norm_frobenius
< typename E::value_type >
>::result_type 
norm_frobenius (const matrix_expression< E > &e)
template<class E>
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_norm_inf< typename
E::value_type > >::result_type 
norm_inf (const vector_expression< E > &e)
template<class E>
BOOST_UBLAS_INLINE
matrix_scalar_unary_traits< E,
matrix_norm_inf< typename
E::value_type > >::result_type 
norm_inf (const matrix_expression< E > &e)
template<>
matrix< std::complex< double > > OneElement (matrix< std::complex< double > >)
template<>
matrix< std::complex< float > > OneElement (matrix< std::complex< float > >)
template<>
std::complex< double > OneElement (std::complex< double >)
template<>
std::complex< float > OneElement (std::complex< float >)
template<>
matrix< double > OneElement (matrix< double >)
template<>
matrix< float > OneElement (matrix< float >)
template<>
double OneElement (double)
template<>
float OneElement (float)
template<class T>
OneElement (T)
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 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.
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, F)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, bool init=true)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, dense_proxy_tag, column_major_tag)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & opb_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, F, dense_proxy_tag, row_major_tag)
template<class E1, class T2>
BOOST_UBLAS_INLINE
vector_binary_scalar2_traits
< E1, const T2,
scalar_multiplies
< BOOST_UBLAS_TYPENAME
E1::value_type, T2 >
, scalar_reference< const T2 >
>::result_type 
operator* (const vector_expression< E1 > &e1, const T2 &e2)
template<class T1, class E2>
BOOST_UBLAS_INLINE
vector_binary_scalar1_traits
< const T1, E2,
scalar_multiplies< T1,
BOOST_UBLAS_TYPENAME
E2::value_type >
, scalar_reference< const T1 >
>::result_type 
operator* (const T1 &e1, const vector_expression< E2 > &e2)
template<class E1, class T2>
BOOST_UBLAS_INLINE
matrix_binary_scalar2_traits
< E1, const T2,
scalar_multiplies
< BOOST_UBLAS_TYPENAME
E1::value_type, T2 >
, scalar_reference< const T2 >
>::result_type 
operator* (const matrix_expression< E1 > &e1, const T2 &e2)
template<class T1, class E2>
BOOST_UBLAS_INLINE
matrix_binary_scalar1_traits
< const T1, E2,
scalar_multiplies< T1,
BOOST_UBLAS_TYPENAME
E2::value_type >
, scalar_reference< const T1 >
>::result_type 
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 
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 
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_minus< typename
E1::value_type, typename
E2::value_type >
>::result_type 
operator- (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
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 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 E>
BOOST_UBLAS_INLINE
matrix_unary1_traits< E,
scalar_negate< typename
E::value_type > >::result_type 
operator- (const matrix_expression< E > &e)
template<class E1, class T2>
BOOST_UBLAS_INLINE
vector_binary_scalar2_traits
< E1, const T2, scalar_divides
< BOOST_UBLAS_TYPENAME
E1::value_type, T2 >
, scalar_reference< const T2 >
>::result_type 
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
< BOOST_UBLAS_TYPENAME
E1::value_type, T2 >
, scalar_reference< const T2 >
>::result_type 
operator/ (const matrix_expression< E1 > &e1, const T2 &e2)
template<class E1, class E2>
bool operator== (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
template<class E1, class E2>
bool operator== (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
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 E1, class E2>
BOOST_UBLAS_INLINE
vector_scalar_binary_traits
< E1, E2, vector_inner_prod
< typename E1::value_type,
typename E2::value_type,
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 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 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 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 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 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 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 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 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 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 M, class E1, class E2>
BOOST_UBLAS_INLINE M & prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m)
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 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 V, class E1, class E2>
BOOST_UBLAS_INLINE V & prod (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, V &v)
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 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 V, class E1, class E2>
BOOST_UBLAS_INLINE V & prod (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, V &v)
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 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 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 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 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 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 >::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 >::range_type &r)
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 A>
BOOST_UBLAS_INLINE
vector_indirect< V,
indirect_array< A > > 
project (V &data, const indirect_array< A > &ia)
template<class V>
BOOST_UBLAS_INLINE const
vector_slice< V > 
project (const vector_slice< V > &data, const typename vector_slice< V >::range_type &r)
template<class V>
BOOST_UBLAS_INLINE
vector_slice< V > 
project (vector_slice< V > &data, const typename vector_slice< V >::range_type &r)
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_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 (V &data, const typename vector_slice< V >::slice_type &s)
template<class V>
BOOST_UBLAS_INLINE const
vector_range< V > 
project (const vector_range< V > &data, const typename vector_range< V >::range_type &r)
template<class V>
BOOST_UBLAS_INLINE
vector_range< V > 
project (vector_range< V > &data, const typename vector_range< V >::range_type &r)
template<class V>
BOOST_UBLAS_INLINE const
vector_range< const V > 
project (const V &data, const typename vector_range< V >::range_type &r)
template<class V>
BOOST_UBLAS_INLINE
vector_range< V > 
project (V &data, const typename vector_range< V >::range_type &r)
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>
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>
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 >::range_type &r1, const typename matrix_slice< M >::range_type &r2)
template<class M>
BOOST_UBLAS_INLINE
matrix_slice< M > 
project (matrix_slice< M > &data, const typename matrix_slice< M >::range_type &r1, const typename matrix_slice< M >::range_type &r2)
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 (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_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_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< 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 (M &data, const typename matrix_range< M >::range_type &r1, const typename matrix_range< M >::range_type &r2)
template<class M, class A>
BOOST_UBLAS_INLINE const
matrix_indirect< const M,
indirect_array< A > > 
project_const (const M &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 
real (const vector_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 M>
BOOST_UBLAS_INLINE matrix_row< M > row (const M &data, typename M::size_type i)
template<class M>
BOOST_UBLAS_INLINE matrix_row< M > row (M &data, typename M::size_type i)
template<class M>
BOOST_UBLAS_INLINE matrix_row
< const M > 
row_const (const M &data, typename M::size_type i)
template<class T>
BOOST_UBLAS_INLINE T same_impl_ex (const T &size1, const T &size2, const char *file, int line)
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 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, 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 M, class E1, class E2>
BOOST_UBLAS_INLINE M sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
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, class F>
BOOST_UBLAS_INLINE M sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, const F &f)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, const F &f, bool init=true)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, const F &f, column_major_tag)
template<class M, class E1, class E2, class F>
BOOST_UBLAS_INLINE M & sparse_prod (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, M &m, const F &f, row_major_tag)
template<class E>
BOOST_UBLAS_INLINE
vector_scalar_unary_traits< E,
vector_sum< typename
E::value_type > >::result_type 
sum (const vector_expression< E > &e)
template<class I, class T, class F, class ALLOC>
BOOST_UBLAS_INLINE void swap (std::map< I, T, F, ALLOC > &a1, std::map< I, T, F, ALLOC > &a2)
template<class PM, class MV>
BOOST_UBLAS_INLINE void swap_rows (const PM &pm, MV &mv)
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, vector_tag)
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< const E,
scalar_identity< typename
E::value_type > >::result_type 
trans (const vector_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< const E,
scalar_identity< typename
E::value_type > >::result_type 
trans (const matrix_expression< E > &e)
template<class F, class V, class E>
BOOST_UBLAS_INLINE void vector_assign (F, V &v, const vector_expression< E > &e)
template<class F, class V, class E>
void vector_assign (F, V &v, const vector_expression< E > &e, sparse_proxy_tag)
template<class F, class V, class E>
void vector_assign (F, V &v, const vector_expression< E > &e, sparse_tag)
template<class F, class V, class E>
void vector_assign (F, V &v, const vector_expression< E > &e, packed_proxy_tag)
template<class F, class V, class E>
void vector_assign (F, V &v, const vector_expression< E > &e, dense_proxy_tag)
template<class F, class V, class T>
BOOST_UBLAS_INLINE void vector_assign_scalar (F, V &v, const T &t)
template<class F, class V, class T>
void vector_assign_scalar (F, V &v, const T &t, sparse_proxy_tag)
template<class F, class V, class T>
void vector_assign_scalar (F, V &v, const T &t, packed_proxy_tag)
template<class F, class V, class T>
void vector_assign_scalar (F, V &v, const T &t, dense_proxy_tag)
template<class F, class V, class E>
BOOST_UBLAS_INLINE void vector_swap (F, V &v, vector_expression< E > &e)
template<class F, class V, class E>
void vector_swap (F, V &v, vector_expression< E > &e, sparse_proxy_tag)
template<class F, class V, class E>
void vector_swap (F, V &v, vector_expression< E > &e, packed_proxy_tag)
template<class F, class V, class E>
void vector_swap (F, V &v, vector_expression< E > &e, dense_proxy_tag)
template<>
matrix< std::complex< double > > ZeroElement (matrix< std::complex< double > >)
template<>
matrix< std::complex< float > > ZeroElement (matrix< std::complex< float > >)
template<>
vector< std::complex< double > > ZeroElement (vector< std::complex< double > >)
template<>
vector< std::complex< float > > ZeroElement (vector< std::complex< float > >)
template<>
std::complex< double > ZeroElement (std::complex< double >)
template<>
std::complex< float > ZeroElement (std::complex< float >)
template<>
matrix< double > ZeroElement (matrix< double >)
template<>
matrix< float > ZeroElement (matrix< float >)
template<>
vector< double > ZeroElement (vector< double >)
template<>
vector< float > ZeroElement (vector< float >)
template<>
double ZeroElement (double)
template<>
float ZeroElement (float)
template<class T>
ZeroElement (T)


Generated by  Doxygen 1.6.0   Back to index