Bayesian Filtering Library  Generated from SVN r
Modules | Namespaces | Classes | Macros | Typedefs | Enumerations | Enumerator | Functions | Variables | Friends
Complex Numbers

Modules

 Exceptions
 

Namespaces

 BFL::boost::numeric::ublas
 main namespace of uBLAS.
 
 BFL::boost
 BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP.
 

Classes

class  ColumnVector_Wrapper
 Class ColumnVectorWrapper. More...
 
class  RowVector_Wrapper
 Class RowVectorWrapper. More...
 
class  Matrix_Wrapper
 Class Matrixwrapper. More...
 
class  SymmetricMatrix_Wrapper
 Class SymmetricMatrixWrapper. More...
 
struct  _Iter_less_iter
 
struct  _Iter_less_val
 
struct  _Val_less_iter
 
struct  _Iter_equal_to_iter
 
struct  _Iter_equal_to_val
 
struct  _Iter_comp_iter< _Compare >
 
struct  _Iter_comp_val< _Compare >
 
struct  _Val_comp_iter< _Compare >
 
struct  _Iter_equals_val< _Value >
 
struct  _Iter_equals_iter< _Iterator1 >
 
struct  _Iter_pred< _Predicate >
 
struct  _Iter_comp_to_val< _Compare, _Value >
 
struct  _Iter_comp_to_iter< _Compare, _Iterator1 >
 
struct  _Iter_negate< _Predicate >
 
class  bad_alloc
 Exception possibly thrown by new.bad_alloc (or classes derived from it) is used to report allocation errors from the throwing forms of new. More...
 
struct  nothrow_t
 
class  Probability
 Class representing a probability (a double between 0 and 1) More...
 
struct  bool_< B >
 
struct  integral_c< I, val >
 
struct  integral_constant< T, val >
 
struct  integral_constant< bool, val >
 
struct  is_integral< T >
 
struct  is_integral< const T >
 
struct  is_integral< volatile const T >
 
struct  is_integral< volatile T >
 
struct  is_integral< unsigned char >
 
struct  is_integral< unsigned short >
 
struct  is_integral< unsigned int >
 
struct  is_integral< unsigned long >
 
struct  is_integral< signed char >
 
struct  is_integral< short >
 
struct  is_integral< int >
 
struct  is_integral< long >
 
struct  is_integral< char >
 
struct  is_integral< bool >
 
struct  is_integral< wchar_t >
 
struct  is_integral< char16_t >
 
struct  is_integral< char32_t >
 
struct  is_floating_point< T >
 
struct  is_floating_point< const T >
 
struct  is_floating_point< volatile const T >
 
struct  is_floating_point< volatile T >
 
struct  is_floating_point< float >
 
struct  is_floating_point< double >
 
struct  is_floating_point< long double >
 
struct  is_arithmetic< T >
 
struct  is_void< T >
 
struct  is_void< void >
 
struct  is_void< const void >
 
struct  is_void< const volatile void >
 
struct  is_void< volatile void >
 
struct  is_fundamental< T >
 
struct  add_reference_impl< T >
 
struct  add_reference_impl< T && >
 
struct  add_reference< T >
 
struct  add_reference< T & >
 
struct  add_reference< void >
 
struct  add_reference< const void >
 
struct  add_reference< const volatile void >
 
struct  add_reference< volatile void >
 
struct  is_lvalue_reference< T >
 
struct  is_lvalue_reference< T & >
 
struct  is_rvalue_reference< T >
 
struct  is_rvalue_reference< T && >
 
struct  is_reference< T >
 
struct  no_type
 
struct  is_array< T >
 
struct  is_array< T[N]>
 
struct  is_array< T const [N]>
 
struct  is_array< T volatile[N]>
 
struct  is_array< T const volatile[N]>
 
struct  is_array< T[]>
 
struct  is_array< T const []>
 
struct  is_array< T const volatile[]>
 
struct  is_array< T volatile[]>
 
struct  is_union< T >
 
struct  is_union< T const >
 
struct  is_union< T volatile const >
 
struct  is_union< T volatile >
 
struct  is_class_impl< T >
 
struct  is_class< T >
 
struct  is_abstract_imp2< T >
 
struct  is_abstract_select< v >::rebind< T >
 
struct  is_abstract_select< v >
 
struct  is_abstract_select< false >::rebind< T >
 
struct  is_abstract_select< false >
 
struct  is_abstract_imp< T >
 
struct  is_abstract< T >
 
struct  add_lvalue_reference< T >
 
struct  add_lvalue_reference< T && >
 
struct  add_rvalue_reference_helper< T, b >
 
struct  add_rvalue_reference_helper< T, true >
 
struct  add_rvalue_reference_imp< T >
 
struct  add_rvalue_reference< T >
 
struct  is_function_ptr_helper< R >
 
struct  is_function_ptr_helper< R(*)()>
 
struct  is_function_ptr_helper< R(*)(...)>
 
struct  is_function_ptr_helper< R(*)(T0)>
 
struct  is_function_ptr_helper< R(*)(T0 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1)>
 
struct  is_function_ptr_helper< R(*)(T0, T1 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)>
 
struct  is_function_ptr_helper< R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)>
 
struct  is_function_chooser< is_ref >::result_< T >
 
struct  is_function_chooser< is_ref >
 
struct  is_function_chooser< false >::result_< T >
 
struct  is_function_chooser< false >
 
struct  is_function_impl< T >
 
struct  is_function< T >
 
struct  is_function< T && >
 
struct  or_helper< A, B, C >
 
struct  is_convertible_basic_impl< From, To, b >
 
class  is_convertible_basic_impl< From, To, false >
 
struct  is_convertible_impl< From, To >
 
struct  is_convertible_impl_select< trivial1, trivial2, abstract_target >::rebind< From, To >
 
struct  is_convertible_impl_select< trivial1, trivial2, abstract_target >
 
struct  is_convertible_impl_select< true, true, false >::rebind< From, To >
 
struct  is_convertible_impl_select< true, true, false >
 
struct  is_convertible_impl_select< false, false, true >::rebind< From, To >
 
struct  is_convertible_impl_select< false, false, true >
 
struct  is_convertible_impl_select< true, false, true >::rebind< From, To >
 
struct  is_convertible_impl_select< true, false, true >
 
struct  is_convertible_impl_dispatch_base< From, To >
 
struct  is_convertible_impl_dispatch< From, To >
 
struct  is_convertible_impl_dispatch< void, void >
 
struct  is_convertible_impl_dispatch< void, void const >
 
struct  is_convertible_impl_dispatch< void, void const volatile >
 
struct  is_convertible_impl_dispatch< void, void volatile >
 
struct  is_convertible_impl_dispatch< void const, void >
 
struct  is_convertible_impl_dispatch< void const, void const >
 
struct  is_convertible_impl_dispatch< void const, void const volatile >
 
struct  is_convertible_impl_dispatch< void const, void volatile >
 
struct  is_convertible_impl_dispatch< void const volatile, void >
 
struct  is_convertible_impl_dispatch< void const volatile, void const >
 
struct  is_convertible_impl_dispatch< void const volatile, void const volatile >
 
struct  is_convertible_impl_dispatch< void const volatile, void volatile >
 
struct  is_convertible_impl_dispatch< void volatile, void >
 
struct  is_convertible_impl_dispatch< void volatile, void const >
 
struct  is_convertible_impl_dispatch< void volatile, void const volatile >
 
struct  is_convertible_impl_dispatch< void volatile, void volatile >
 
struct  is_convertible_impl_dispatch< void, To >
 
struct  is_convertible_impl_dispatch< From, void >
 
struct  is_convertible_impl_dispatch< void const, To >
 
struct  is_convertible_impl_dispatch< From, void const >
 
struct  is_convertible_impl_dispatch< void const volatile, To >
 
struct  is_convertible_impl_dispatch< From, void const volatile >
 
struct  is_convertible_impl_dispatch< void volatile, To >
 
struct  is_convertible_impl_dispatch< From, void volatile >
 
struct  is_convertible< From, To >
 
struct  is_class_or_union< T >
 
struct  int_convertible
 
struct  is_enum_helper< is_typename_arithmetic_or_reference >::type< T >
 
struct  is_enum_helper< is_typename_arithmetic_or_reference >
 
struct  is_enum_helper< false >::type< T >
 
struct  is_enum_helper< false >
 
struct  is_enum_impl< T >
 
struct  is_enum< T >
 
struct  is_same< T, U >
 
struct  is_same< T, T >
 
struct  remove_cv< T >
 
struct  remove_cv< T const >
 
struct  remove_cv< T volatile >
 
struct  remove_cv< T const volatile >
 
struct  remove_cv< T const [N]>
 
struct  remove_cv< T const volatile[N]>
 
struct  remove_cv< T volatile[N]>
 
struct  remove_cv< T const []>
 
struct  remove_cv< T const volatile[]>
 
struct  remove_cv< T volatile[]>
 
struct  bd_helper< B, D >
 
struct  is_base_and_derived_impl2< B, D >::Host
 
struct  is_base_and_derived_impl2< B, D >
 
struct  is_base_and_derived_impl3< B, D >
 
struct  is_base_and_derived_select< ic1, ic2, iss >::rebind< T, U >
 
struct  is_base_and_derived_select< ic1, ic2, iss >
 
struct  is_base_and_derived_select< true, true, false >::rebind< T, U >
 
struct  is_base_and_derived_select< true, true, false >
 
struct  is_base_and_derived_impl< B, D >
 
struct  is_base_and_derived< Base, Derived >
 
struct  is_base_and_derived< Base &, Derived >
 
struct  is_base_and_derived< Base, Derived & >
 
struct  is_base_and_derived< Base &, Derived & >
 
struct  value_type_wknd< T >
 
struct  is_na< T >
 
struct  is_na< na >
 
struct  is_not_na< T >
 
struct  is_not_na< na >
 
struct  if_na< T, U >
 
struct  if_na< na, U >
 
struct  template_arity< F >
 
struct  lambda< T, Tag >
 
struct  if_c< C, T1, T2 >
 
struct  if_c< false, T1, T2 >
 
struct  if_< BOOST_MPL_AUX_NA_PARAM, BOOST_MPL_AUX_NA_PARAM, BOOST_MPL_AUX_NA_PARAM >
 
struct  eval_if< BOOST_MPL_AUX_NA_PARAM, BOOST_MPL_AUX_NA_PARAM, BOOST_MPL_AUX_NA_PARAM >
 
struct  eval_if_c< C, F1, F2 >
 
struct  implementation_level_impl< T >::traits_class_level< U >
 
struct  implementation_level_impl< T >
 
struct  implementation_level< T >
 
struct  identity< BOOST_MPL_AUX_NA_PARAM >
 
struct  make_identity< BOOST_MPL_AUX_NA_PARAM >
 
struct  BOOST_MPL_AUX_NUMERIC_CAST< SourceTag, TargetTag >::apply< N >
 
struct  BOOST_MPL_AUX_NUMERIC_CAST< SourceTag, TargetTag >
 
struct  type_wrapper< T >
 
struct  wrapped_type< T >
 
struct  wrapped_type< type_wrapper< T > >
 
struct  yes_no_tag< C_ >
 
struct  yes_no_tag< true >
 
struct  weighted_tag<>
 
struct  is_void_< T >
 
struct  is_void_< void_ >
 
struct  is_not_void_< T >
 
struct  is_not_void_< void_ >
 
struct  tag_impl< T >
 
struct  tag< T, Default >
 
struct  cast1st_impl< F, Tag1, Tag2 >::apply< N1, N2 >
 
struct  cast1st_impl< F, Tag1, Tag2 >
 
struct  cast2nd_impl< F, Tag1, Tag2 >::apply< N1, N2 >
 
struct  cast2nd_impl< F, Tag1, Tag2 >
 
struct  msvc_eti_base< T >
 
struct  msvc_eti_base< int >
 
struct  is_pointer< T >
 
struct  is_pointer< T * >
 
struct  is_pointer< T *const >
 
struct  is_pointer< T *const volatile >
 
struct  is_pointer< T *volatile >
 
struct  basic_traits
 
struct  extended_type_info_impl< T >
 
struct  traits< T, Level, Tracking, Version, ETII, Wrapper >
 
struct  type_info_implementation< T >::traits_class_typeinfo_implementation< U >
 
struct  type_info_implementation< T >
 
struct  tracking_level_impl< T >::traits_class_tracking< U >
 
struct  tracking_level_impl< T >
 
struct  tracking_level< T >
 
class  iserializer< Archive, T >
 
class  oserializer< Archive, T >
 
struct  member_saver< Archive, T >
 
struct  member_loader< Archive, T >
 
class  access
 
class  interface_oarchive< Archive >
 
class  interface_iarchive< Archive >
 
struct  is_const< T >
 
struct  is_const< T const >
 
struct  is_const< T const [N]>
 
struct  is_const< T const []>
 
struct  is_polymorphic_imp1< T >::d1
 
struct  is_polymorphic_imp1< T >::d2::unique
 
struct  is_polymorphic_imp1< T >::d2
 
struct  is_polymorphic_imp1< T >
 
struct  is_polymorphic_imp1< T const >
 
struct  is_polymorphic_imp1< T const volatile >
 
struct  is_polymorphic_imp1< T volatile >
 
struct  is_polymorphic_imp2< T >
 
struct  is_polymorphic_selector< is_class >::rebind< T >
 
struct  is_polymorphic_selector< is_class >
 
struct  is_polymorphic_selector< true >::rebind< T >
 
struct  is_polymorphic_selector< true >
 
struct  is_polymorphic_imp< T >
 
struct  is_polymorphic< T >
 
struct  base_cast< B, D >
 
struct  base_register< Base, Derived >::polymorphic
 
struct  base_register< Base, Derived >::non_polymorphic
 
struct  base_register< Base, Derived >
 
struct  wrapper_traits< T, Level, Tracking, Version, ETII >
 
struct  is_wrapper_impl< T >
 
struct  is_wrapper< T >
 
class  addressof_ref< T >
 
struct  address_of< T >
 
struct  address_of< addressof_null_t >
 
struct  address_of< const addressof_null_t >
 
struct  address_of< volatile addressof_null_t >
 
struct  address_of< const volatile addressof_null_t >
 
struct  addressof_void< class >
 
struct  addressof_member_operator< T, E >
 
struct  addressof_member_operator< T, typename addressof_void< decltype(addressof_declval< T & >().operator &())>::type >
 
struct  addressof_non_member_operator< T, E >
 
struct  addressof_non_member_operator< T, typename addressof_void< decltype(operator &(addressof_declval< T & >()))>::type >
 
struct  addressof_expression< T, E >
 
struct  addressof_expression< T, typename addressof_void< decltype(&addressof_declval< T & >())>::type >
 
struct  addressof_is_constexpr< T >
 
struct  addressof_if< E, T >
 
struct  addressof_if< true, T >
 
struct  nvp< T >
 
struct  implementation_level< nvp< T > >
 
struct  tracking_level< nvp< T > >
 
class  empty_base< T >
 
struct  less_than_comparable2< T, U, B >
 
struct  less_than_comparable1< T, B >
 
struct  equality_comparable2< T, U, B >
 
struct  equality_comparable1< T, B >
 
struct  incrementable< T, B >
 
struct  decrementable< T, B >
 
struct  dereferenceable< T, P, B >
 
struct  indexable< T, I, R, B >
 
struct  equivalent2< T, U, B >
 
struct  equivalent1< T, B >
 
struct  partially_ordered2< T, U, B >
 
struct  partially_ordered1< T, B >
 
struct  totally_ordered2< T, U, B >
 
struct  totally_ordered1< T, B >
 
struct  additive2< T, U, B >
 
struct  additive1< T, B >
 
struct  multiplicative2< T, U, B >
 
struct  multiplicative1< T, B >
 
struct  integer_multiplicative2< T, U, B >
 
struct  integer_multiplicative1< T, B >
 
struct  arithmetic2< T, U, B >
 
struct  arithmetic1< T, B >
 
struct  integer_arithmetic2< T, U, B >
 
struct  integer_arithmetic1< T, B >
 
struct  bitwise2< T, U, B >
 
struct  bitwise1< T, B >
 
struct  unit_steppable< T, B >
 
struct  shiftable2< T, U, B >
 
struct  shiftable1< T, B >
 
struct  ring_operators2< T, U, B >
 
struct  ring_operators1< T, B >
 
struct  ordered_ring_operators2< T, U, B >
 
struct  ordered_ring_operators1< T, B >
 
struct  field_operators2< T, U, B >
 
struct  field_operators1< T, B >
 
struct  ordered_field_operators2< T, U, B >
 
struct  ordered_field_operators1< T, B >
 
struct  euclidian_ring_operators2< T, U, B >
 
struct  euclidian_ring_operators1< T, B >
 
struct  ordered_euclidian_ring_operators2< T, U, B >
 
struct  ordered_euclidian_ring_operators1< T, B >
 
struct  euclidean_ring_operators2< T, U, B >
 
struct  euclidean_ring_operators1< T, B >
 
struct  ordered_euclidean_ring_operators2< T, U, B >
 
struct  ordered_euclidean_ring_operators1< T, B >
 
struct  input_iteratable< T, P, B >
 
struct  output_iteratable< T, B >
 
struct  forward_iteratable< T, P, B >
 
struct  bidirectional_iteratable< T, P, B >
 
struct  random_access_iteratable< T, P, D, R, B >
 
struct  true_t
 
struct  false_t
 
struct  is_chained_base< T >
 
struct  operators2< T, U >
 
struct  operators< T, U >
 
struct  operators<T, T >
 
struct  iterator_helper< Category, T, Distance, Pointer, Reference >
 
struct  input_iterator_helper< T, V, D, P, R >
 
struct  output_iterator_helper< T >
 
struct  forward_iterator_helper< T, V, D, P, R >
 
struct  bidirectional_iterator_helper< T, V, D, P, R >
 
struct  random_access_iterator_helper< T, V, D, P, R >
 
struct  is_mem_fun_pointer_impl< T >
 
struct  is_mem_fun_pointer_impl< R(T::*)() >
 
struct  is_mem_fun_pointer_impl< R(T::*)(...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)() const >
 
struct  is_mem_fun_pointer_impl< R(T::*)() volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)() const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) volatile >
 
struct  is_mem_fun_pointer_impl< R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const volatile >
 
struct  is_member_function_pointer< T >
 
struct  is_member_pointer< T >
 
struct  is_member_pointer< U T::*>
 
struct  is_member_pointer< U T::*const >
 
struct  is_member_pointer< U T::*const volatile >
 
struct  is_member_pointer< U T::*volatile >
 
struct  is_scalar< T >
 
struct  is_POD< T >
 
struct  is_pod< T >
 
struct  is_pod< T[sz]>
 
struct  is_pod< void >
 
struct  is_pod< void const >
 
struct  is_pod< void const volatile >
 
struct  is_pod< void volatile >
 
struct  is_volatile< T >
 
struct  is_volatile< T volatile >
 
struct  is_volatile< T volatile[N]>
 
struct  is_volatile< T volatile[]>
 
struct  is_assignable< T, U >
 
struct  is_assignable_imp
 
struct  is_assignable< T[N], U >
 
struct  is_assignable< T(&)[N], U >
 
struct  is_assignable< T[], U >
 
struct  is_assignable< T(&)[], U >
 
struct  is_assignable< void, U >
 
struct  is_assignable< void const, U >
 
struct  is_assignable< void volatile, U >
 
struct  is_assignable< void const volatile, U >
 
struct  has_trivial_assign< T >
 
struct  has_trivial_assign< void >
 
struct  has_trivial_assign< void const >
 
struct  has_trivial_assign< void const volatile >
 
struct  has_trivial_assign< void volatile >
 
struct  has_trivial_assign< T volatile >
 
struct  has_trivial_assign< T & >
 
struct  has_trivial_assign< T && >
 
struct  has_trivial_assign< T[N]>
 
struct  has_trivial_assign< T[]>
 
struct  remove_rvalue_ref< T >
 
struct  remove_rvalue_ref< T && >
 
struct  remove_reference< T >
 
struct  remove_reference< T & >
 
struct  has_nothrow_assign_imp< T, b1, b2 >
 
struct  has_nothrow_assign_imp< T, false, true >
 
struct  has_nothrow_assign_imp< T[N], false, true >
 
struct  has_nothrow_assign_imp< T[], false, true >
 
struct  has_nothrow_assign< T >
 
struct  has_nothrow_assign< T[N]>
 
struct  has_nothrow_assign< void >
 
struct  has_nothrow_assign< T volatile >
 
struct  has_nothrow_assign< T & >
 
struct  has_nothrow_assign< T && >
 
struct  has_nothrow_assign< void const >
 
struct  has_nothrow_assign< void const volatile >
 
struct  has_nothrow_assign< void volatile >
 
struct  is_default_constructible_imp
 
struct  is_default_constructible< T >
 
struct  is_default_constructible< T[N]>
 
struct  is_default_constructible< T[]>
 
struct  is_default_constructible< T & >
 
struct  is_default_constructible< T && >
 
struct  is_default_constructible< void >
 
struct  is_default_constructible< void const >
 
struct  is_default_constructible< void volatile >
 
struct  is_default_constructible< void const volatile >
 
struct  remove_all_extents< T >
 
struct  remove_all_extents< T[N]>
 
struct  remove_all_extents< T const [N]>
 
struct  remove_all_extents< T volatile[N]>
 
struct  remove_all_extents< T const volatile[N]>
 
struct  remove_all_extents< T[]>
 
struct  remove_all_extents< T const []>
 
struct  remove_all_extents< T volatile[]>
 
struct  remove_all_extents< T const volatile[]>
 
struct  has_nothrow_constructor_imp< T, b >
 
struct  has_nothrow_constructor_imp< T, true >
 
struct  has_nothrow_constructor_imp< T[N], true >
 
struct  has_nothrow_constructor< T >
 
struct  has_nothrow_constructor< void >
 
struct  has_nothrow_constructor< void const >
 
struct  has_nothrow_constructor< void const volatile >
 
struct  has_nothrow_constructor< void volatile >
 
struct  has_nothrow_default_constructor< T >
 
struct  is_destructible_imp
 
struct  is_destructible< T >
 
struct  is_destructible< void >
 
struct  is_destructible< void const >
 
struct  is_destructible< void volatile >
 
struct  is_destructible< void const volatile >
 
struct  is_destructible< T & >
 
struct  is_destructible< T && >
 
struct  is_destructible< T[N]>
 
struct  is_destructible< T[]>
 
struct  is_constructible_imp
 
struct  is_constructible< T, Args >
 
struct  is_constructible< T, Arg >
 
struct  is_constructible< Ref &, Arg >
 
struct  is_constructible< Ref &&, Arg >
 
struct  is_constructible< void >
 
struct  is_constructible< void const >
 
struct  is_constructible< void const volatile >
 
struct  is_constructible< void volatile >
 
struct  is_constructible< T >
 
struct  is_copy_constructible< T >
 
struct  is_copy_constructible< void >
 
struct  is_copy_constructible< void const >
 
struct  is_copy_constructible< void const volatile >
 
struct  is_copy_constructible< void volatile >
 
struct  has_nothrow_copy_constructor_imp< T, b >
 
struct  has_nothrow_copy_constructor_imp< T, true >
 
struct  has_nothrow_copy_constructor< T >
 
struct  has_nothrow_copy_constructor< void >
 
struct  has_nothrow_copy_constructor< T volatile >
 
struct  has_nothrow_copy_constructor< T & >
 
struct  has_nothrow_copy_constructor< T && >
 
struct  has_nothrow_copy_constructor< void const >
 
struct  has_nothrow_copy_constructor< void volatile >
 
struct  has_nothrow_copy_constructor< void const volatile >
 
struct  has_nothrow_copy< T >
 
struct  free_saver< Archive, T >
 
struct  free_loader< Archive, T >
 
struct  is_bitwise_serializable< T >
 
class  collection_size_type
 
struct  always< Value >::apply<>
 
struct  always< Value >
 
struct  not_impl<>
 
struct  not_< BOOST_MPL_AUX_NA_PARAM >
 
struct  assert_::types< T1, T2, T3, T4 >
 
struct  next< BOOST_MPL_AUX_NA_PARAM >
 
struct  prior< BOOST_MPL_AUX_NA_PARAM >
 
struct  protect< BOOST_MPL_AUX_NA_PARAM, not_le_ >
 
struct  remove_const< T >
 
struct  remove_const< T const >
 
struct  remove_const< T const [N]>
 
struct  remove_const< T const []>
 
struct  use_array_optimization< Archive >
 
class  array_wrapper< T >
 
class  noncopyable
 
class  unbounded_array< T, ALLOC >
 
class  bounded_array< T, N, ALLOC >
 
class  basic_range< Z, D >::const_iterator
 
class  basic_range< Z, D >
 
class  basic_slice< Z, D >::const_iterator
 
class  basic_slice< Z, D >
 
class  indirect_array< A >::const_iterator
 
class  indirect_array< A >
 
class  map_std< I, T, ALLOC >
 
class  map_array< I, T, ALLOC >
 
struct  scalar_tag
 
struct  vector_tag
 
class  vector_expression< E >
 Base class for Vector Expression models. More...
 
class  vector_container< C >
 Base class for Vector container models. More...
 
class  vector_reference< E >
 
struct  matrix_tag
 
class  matrix_expression< E >
 Base class for Matrix Expression models. More...
 
class  matrix_container< C >
 Base class for Matrix container models. More...
 
class  matrix_reference< E >
 
class  vector_range< V >::const_iterator
 
class  vector_range< V >::iterator
 
class  vector_range< V >
 A vector referencing a continuous subvector of elements of vector v containing all elements specified by range. More...
 
class  vector_slice< V >::const_iterator
 
class  vector_slice< V >::iterator
 
class  vector_slice< V >
 A vector referencing a non continuous subvector of elements of vector v containing all elements specified by slice. More...
 
class  vector_indirect< V, IA >::const_iterator
 
class  vector_indirect< V, IA >::iterator
 
class  vector_indirect< V, IA >
 A vector referencing a non continuous subvector of elements given another vector of indices. More...
 
class  matrix_row< M >::const_iterator
 
class  matrix_row< M >::iterator
 
class  matrix_row< M >
 
class  matrix_column< M >::const_iterator
 
class  matrix_column< M >::iterator
 
class  matrix_column< M >
 
class  matrix_vector_range< M >::const_iterator
 
class  matrix_vector_range< M >::iterator
 
class  matrix_vector_range< M >
 
class  matrix_vector_slice< M >::const_iterator
 
class  matrix_vector_slice< M >::iterator
 
class  matrix_vector_slice< M >
 
class  matrix_vector_indirect< M, IA >::const_iterator
 
class  matrix_vector_indirect< M, IA >::iterator
 
class  matrix_vector_indirect< M, IA >
 
class  matrix_range< M >::const_iterator1
 
class  matrix_range< M >::iterator1
 
class  matrix_range< M >::const_iterator2
 
class  matrix_range< M >::iterator2
 
class  matrix_range< M >
 
class  matrix_slice< M >::const_iterator1
 
class  matrix_slice< M >::iterator1
 
class  matrix_slice< M >::const_iterator2
 
class  matrix_slice< M >::iterator2
 
class  matrix_slice< M >
 
class  matrix_indirect< M, IA >::const_iterator1
 
class  matrix_indirect< M, IA >::iterator1
 
class  matrix_indirect< M, IA >::const_iterator2
 
class  matrix_indirect< M, IA >::iterator2
 
class  matrix_indirect< M, IA >
 A matrix referencing a non continuous submatrix of elements given another matrix of indices. More...
 
class  vector< T, A >::const_iterator
 
class  vector< T, A >::iterator
 
class  vector< T, A >
 A dense vector of values of type T. More...
 
class  bounded_vector< T, N >
 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< T, ALLOC >::const_iterator
 
class  unit_vector< T, ALLOC >
 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< T, ALLOC >::const_iterator
 
class  zero_vector< T, ALLOC >
 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< T, ALLOC >::const_iterator
 
class  scalar_vector< T, ALLOC >
 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< T, N >::const_iterator
 
class  c_vector< T, N >::iterator
 
class  c_vector< T, N >
 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< T, A >
 
class  compressed_vector< T, IB, IA, TA >
 
class  coordinate_vector< T, IB, IA, TA >
 
struct  unknown_orientation_tag
 
struct  row_major_tag
 
struct  column_major_tag
 
struct  basic_row_major< Z, D >
 
struct  basic_column_major< Z, D >
 
class  matrix< T, L, A >::const_iterator1
 
class  matrix< T, L, A >::iterator1
 
class  matrix< T, L, A >::const_iterator2
 
class  matrix< T, L, A >::iterator2
 
class  matrix< T, L, A >
 A dense matrix of values of type T. More...
 
class  bounded_matrix< T, M, N, L >
 A dense matrix of values of type T with a variable size bounded to a maximum of $M$ by $N$. More...
 
class  identity_matrix< T, ALLOC >::const_iterator1
 
class  identity_matrix< T, ALLOC >::const_iterator2
 
class  identity_matrix< T, ALLOC >
 An identity matrix with values of type T. More...
 
class  zero_matrix< T, ALLOC >::const_iterator1
 
class  zero_matrix< T, ALLOC >::const_iterator2
 
class  zero_matrix< T, ALLOC >
 A matrix with all values of type T equal to zero. More...
 
class  scalar_matrix< T, ALLOC >::const_iterator1
 
class  scalar_matrix< T, ALLOC >::const_iterator2
 
class  scalar_matrix< T, ALLOC >
 A matrix with all values of type T equal to the same value. More...
 
class  c_matrix< T, N, M >::const_iterator1
 
class  c_matrix< T, N, M >::iterator1
 
class  c_matrix< T, N, M >::const_iterator2
 
class  c_matrix< T, N, M >::iterator2
 
class  c_matrix< T, N, M >
 An array based matrix class which size is defined at type specification or object instanciation. More...
 
class  vector_of_vector< T, L, A >::const_iterator1
 
class  vector_of_vector< T, L, A >::iterator1
 
class  vector_of_vector< T, L, A >::const_iterator2
 
class  vector_of_vector< T, L, A >::iterator2
 
class  vector_of_vector< T, L, A >
 A dense matrix of values of type T stored as a vector of vectors. More...
 
class  generalized_vector_of_vector< T, L, A >
 
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< Z >
 
struct  basic_lower< Z >
 
struct  basic_upper< Z >
 
struct  basic_unit_lower< Z >
 
struct  basic_unit_upper< Z >
 
struct  basic_strict_lower< Z >
 
struct  basic_strict_upper< Z >
 
class  banded_matrix< T, L, A >
 
class  diagonal_matrix< T, L, A >
 
class  triangular_matrix< T, TRI, L, A >::const_iterator1
 
class  triangular_matrix< T, TRI, L, A >::iterator1
 
class  triangular_matrix< T, TRI, L, A >::const_iterator2
 
class  triangular_matrix< T, TRI, L, A >::iterator2
 
class  triangular_matrix< T, TRI, L, A >
 A triangular matrix of values of type T. More...
 
class  triangular_adaptor< M, TRI >::const_iterator1
 
class  triangular_adaptor< M, TRI >::iterator1
 
class  triangular_adaptor< M, TRI >::const_iterator2
 
class  triangular_adaptor< M, TRI >::iterator2
 
class  triangular_adaptor< M, TRI >
 
class  symmetric_matrix< T, TRI, L, A >::const_iterator1
 
class  symmetric_matrix< T, TRI, L, A >::iterator1
 
class  symmetric_matrix< T, TRI, L, A >::const_iterator2
 
class  symmetric_matrix< T, TRI, L, A >::iterator2
 
class  symmetric_matrix< T, TRI, L, A >
 
class  symmetric_adaptor< M, TRI >::const_iterator1
 
class  symmetric_adaptor< M, TRI >::iterator1
 
class  symmetric_adaptor< M, TRI >::const_iterator2
 
class  symmetric_adaptor< M, TRI >::iterator2
 
class  symmetric_adaptor< M, TRI >
 
class  hermitian_matrix< T, TRI, L, A >
 
class  hermitian_adaptor< M, TRI >
 
class  mapped_matrix< T, L, A >
 
class  mapped_vector_of_mapped_vector< T, L, A >
 
class  compressed_matrix< T, L, IB, IA, TA >
 
class  coordinate_matrix< T, L, IB, IA, TA >
 
class  nonassignable
 
class  noalias_proxy< C >
 
struct  dimension_properties< dimension >
 
struct  dimension_properties< 1 >
 
struct  dimension_properties< 2 >
 
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< C >
 Base class of all proxy classes that contain a (redirectable) reference to an immutable object. More...
 
class  container_reference< C >
 Base class of all proxy classes that contain a (redirectable) reference to a mutable object. More...
 
struct  forward_iterator_base< IC, I, T >
 Base class of all forward iterators. More...
 
struct  bidirectional_iterator_base< IC, I, T >
 Base class of all bidirectional iterators. More...
 
struct  random_access_iterator_base< IC, I, T, D >
 Base class of all random access iterators. More...
 
class  reverse_iterator_base< I >
 Base class of all reverse iterators. (non-MSVC version) More...
 
class  reverse_iterator_base1< I >
 1st base class of all matrix reverse iterators. (non-MSVC version) More...
 
class  reverse_iterator_base2< I >
 2nd base class of all matrix reverse iterators. (non-MSVC version) More...
 
class  indexed_iterator< C, IC >
 A class implementing an indexed random access iterator. More...
 
class  indexed_const_iterator< C, IC >
 A class implementing an indexed random access iterator. More...
 
class  indexed_iterator2< C, IC >
 A class implementing an indexed random access iterator of a matrix. More...
 
class  indexed_iterator1< C, IC >
 A class implementing an indexed random access iterator of a matrix. More...
 
class  indexed_const_iterator2< C, IC >
 A class implementing an indexed random access iterator of a matrix. More...
 
class  indexed_const_iterator1< C, IC >
 A class implementing an indexed random access iterator of a matrix. More...
 
struct  at_impl< Tag >::apply< Sequence, N >
 
struct  at_impl< Tag >
 
struct  at< BOOST_MPL_AUX_NA_PARAM, BOOST_MPL_AUX_NA_PARAM >
 
struct  vector_tag<>
 
struct  long_<>
 
struct  AUX_WRAPPER_NAME<>
 
struct  v_at<>
 
struct  at_impl< aux::vector_tag< n_ > >::apply<>
 
struct  at_impl< aux::vector_tag< n_ > >
 
struct  front_impl< Tag >
 
struct  front< Sequence >
 
struct  front_impl< aux::vector_tag< n_ > >::apply< Vector >
 
struct  front_impl< aux::vector_tag< n_ > >
 
struct  push_front_impl< Tag >
 
struct  push_front< Sequence, T >
 
struct  pop_front_impl< Tag >
 
struct  pop_front< Sequence >
 
struct  push_back_impl< Tag >
 
struct  push_back< Sequence, T >
 
struct  pop_back_impl< Tag >
 
struct  pop_back< Sequence >
 
struct  back_impl< Tag >
 
struct  back< Sequence >
 
struct  back_impl< aux::vector_tag< n_ > >::apply< Vector >
 
struct  back_impl< aux::vector_tag< n_ > >
 
struct  clear_impl< Tag >
 
struct  clear< Sequence >
 
struct  forward_iterator_tag
 
struct  bidirectional_iterator_tag
 
struct  random_access_iterator_tag
 
struct  integral_rank< T >
 
struct  integral_rank< bool >
 
struct  integral_rank< signed char >
 
struct  integral_rank< char >
 
struct  integral_rank< unsigned char >
 
struct  integral_rank< wchar_t >
 
struct  integral_rank< short >
 
struct  integral_rank< unsigned short >
 
struct  integral_rank< int >
 
struct  integral_rank< unsigned int >
 
struct  integral_rank< long >
 
struct  integral_rank< unsigned long >
 
struct  largest_int< T1, T2 >
 
struct  advance_impl< Tag >::apply< Iterator, N >
 
struct  advance_impl< Tag >
 
struct  advance< BOOST_MPL_AUX_NA_PARAM, BOOST_MPL_AUX_NA_PARAM >
 
struct  distance_impl< Tag >
 
struct  distance< First, Last >
 
struct  v_iter< Vector, >
 
struct  next< v_iter< Vector, n_ > >
 
struct  prior< v_iter< Vector, n_ > >
 
struct  advance< v_iter< Vector, n_ >, Distance >
 
struct  distance< v_iter< Vector, n_ >, v_iter< Vector, m_ > >
 
struct  vector0< Dummy >
 
struct  vector0< na >
 
struct  clear_impl< aux::vector_tag< N > >::apply< Vector >
 
struct  clear_impl< aux::vector_tag< N > >
 
struct  O1_size_impl< Tag >
 
struct  O1_size< Sequence >
 
struct  O1_size_impl< aux::vector_tag< N > >::apply< Vector >
 
struct  O1_size_impl< aux::vector_tag< N > >
 
struct  size_impl< Tag >
 
struct  size< Sequence >
 
struct  size_impl< aux::vector_tag< N > >
 
struct  empty_impl< Tag >
 
struct  empty< Sequence >
 
struct  empty_impl< aux::vector_tag< 0 > >::apply< Vector >
 
struct  empty_impl< aux::vector_tag< 0 > >
 
struct  empty_impl< aux::vector_tag< N > >::apply< Vector >
 
struct  empty_impl< aux::vector_tag< N > >
 
struct  begin_impl< Tag >::apply< Sequence >
 
struct  begin_impl< Tag >
 
struct  end_impl< Tag >::apply< Sequence >
 
struct  end_impl< Tag >
 
struct  begin< BOOST_MPL_AUX_NA_PARAM >
 
struct  end< BOOST_MPL_AUX_NA_PARAM >
 
struct  sequence_tag< BOOST_MPL_AUX_NA_PARAM >
 
struct  begin_type< Sequence >
 
struct  end_type< Sequence >
 
struct  sequence_tag_impl< has_tag_, has_begin_ >::result2_< Sequence >
 
struct  sequence_tag_impl< has_tag_, has_begin_ >
 
struct  negate_impl< Tag >
 
struct  negate_tag< T >
 
struct  negate< BOOST_MPL_AUX_NA_PARAM >
 
struct  negate_impl< integral_c_tag >::apply< N >
 
struct  negate_impl< integral_c_tag >
 
struct  advance_c< Iterator, >
 
struct  msvc_type< T >
 
struct  msvc_type< int >
 
struct  deref< BOOST_MPL_AUX_NA_PARAM >
 
struct  at_c< Sequence, >
 
struct  enable_if_has_type< T, R >
 
struct  enable_if_c< B, T >
 
struct  enable_if_c< false, T >
 
struct  enable_if< Cond, T >
 
struct  lazy_enable_if_c< B, T >
 
struct  lazy_enable_if_c< false, T >
 
struct  lazy_enable_if< Cond, T >
 
struct  disable_if_c< B, T >
 
struct  disable_if_c< true, T >
 
struct  disable_if< Cond, T >
 
struct  lazy_disable_if_c< B, T >
 
struct  lazy_disable_if_c< true, T >
 
struct  lazy_disable_if< Cond, T >
 
struct  error_cant_deduce_type
 
struct  is_basic< T, PlainT >
 
struct  base_result_of< X, Y >
 
struct  add_const< T >
 
struct  add_const< T & >
 
struct  add_cv< T >
 
struct  add_cv< T & >
 
struct  add_pointer< T >
 
struct  add_volatile< T >
 
struct  add_volatile< T & >
 
struct  alignment_of< T >
 
struct  alignment_of_hack< T >
 
struct  alignment_logic< A, S >
 
struct  alignment_of_impl< T >
 
struct  alignment_of< T & >
 
struct  alignment_of< void >
 
struct  alignment_of< void const >
 
struct  alignment_of< void const volatile >
 
struct  alignment_of< void volatile >
 
union  max_align
 
struct  long_double_alignment< Target, check >
 
struct  long_double_alignment< Target, false >
 
struct  double_alignment< Target, check >
 
struct  double_alignment< Target, false >
 
struct  long_alignment< Target, check >
 
struct  long_alignment< Target, false >
 
struct  int_alignment< Target, check >
 
struct  int_alignment< Target, false >
 
struct  short_alignment< Target, check >
 
struct  short_alignment< Target, false >
 
struct  char_alignment< Target, check >
 
struct  char_alignment< Target, false >
 
struct  type_with_alignment< Align >
 
struct  conditional< b, T, U >
 
struct  conditional< false, T, U >
 
union  aligned_storage_imp< size_, alignment_ >::data_t
 
struct  aligned_storage_imp< size_, alignment_ >
 
union  aligned_storage_imp< size, std::size_t(-1)>::data_t
 
struct  aligned_storage_imp< size, std::size_t(-1)>
 
struct  aligned_storage_imp< 0u, alignment_ >
 
class  aligned_storage< size_, alignment_ >
 
struct  is_pod< ::boost::detail::aligned_storage::aligned_storage_imp< size_, alignment_ > >
 
struct  remove_extent< T >
 
struct  remove_extent< T[N]>
 
struct  remove_extent< T const [N]>
 
struct  remove_extent< T volatile [N]>
 
struct  remove_extent< T const volatile [N]>
 
struct  remove_extent< T[]>
 
struct  remove_extent< T const []>
 
struct  remove_extent< T volatile[]>
 
struct  remove_extent< T const volatile[]>
 
struct  remove_bounds< T >
 
struct  decay_imp< T, Array, Function >
 
struct  decay_imp< T, true, false >
 
struct  decay_imp< T, false, true >
 
struct  decay< T >
 
struct  mp_valid_impl< F, T >
 
struct  mp_empty
 
struct  mp_defer_impl< F, T >
 
struct  common_type< T >
 
struct  common_type< T1, T2, T... >
 
struct  common_type< T >
 
struct  common_type_impl< T1, T2 >
 
struct  common_type_decay_helper< T1, T2, T1d, T2d >
 
struct  common_type_decay_helper< T1, T2, T1, T2 >
 
struct  common_type< T1, T2 >
 
struct  copy_cv< T, U >
 
struct  extent_imp< T, N >
 
struct  extent_imp< T[R], N >
 
struct  extent_imp< T const [R], N >
 
struct  extent_imp< T volatile[R], N >
 
struct  extent_imp< T const volatile[R], N >
 
struct  extent_imp< T[R], 0 >
 
struct  extent_imp< T const [R], 0 >
 
struct  extent_imp< T volatile[R], 0 >
 
struct  extent_imp< T const volatile[R], 0 >
 
struct  extent_imp< T[], N >
 
struct  extent_imp< T const [], N >
 
struct  extent_imp< T volatile[], N >
 
struct  extent_imp< T const volatile[], N >
 
struct  extent_imp< T[], 0 >
 
struct  extent_imp< T const [], 0 >
 
struct  extent_imp< T volatile[], 0 >
 
struct  extent_imp< T const volatile[], 0 >
 
struct  extent< T, N >
 
struct  floating_point_promotion< T >
 
struct  floating_point_promotion< float >
 
struct  floating_point_promotion< float const >
 
struct  floating_point_promotion< float volatile >
 
struct  floating_point_promotion< float const volatile >
 
struct  function_traits_helper< Function >
 
struct  function_traits_helper< R(*)(void)>
 
struct  function_traits_helper< R(*)(T1)>
 
struct  function_traits_helper< R(*)(T1, T2)>
 
struct  function_traits_helper< R(*)(T1, T2, T3)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4, T5)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4, T5, T6)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4, T5, T6, T7)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4, T5, T6, T7, T8)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
 
struct  function_traits_helper< R(*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
 
struct  function_traits< Function >
 
struct  is_base_of_imp< B, D >
 
struct  is_base_of< Base, Derived >
 
struct  is_base_of< Base, Derived & >
 
struct  is_base_of< Base &, Derived & >
 
struct  is_base_of< Base &, Derived >
 
struct  remove_pointer< T >
 
struct  remove_pointer< T * >
 
struct  remove_pointer< T *const >
 
struct  remove_pointer< T *volatile >
 
struct  remove_pointer< T *const volatile >
 
struct  BOOST_TT_TRAIT_NAME< Lhs, Rhs, Ret >
 
struct  test< U, x >
 
struct  has_new_operator_impl< T >
 
struct  has_new_operator< T >
 
struct  has_trivial_destructor< T >
 
struct  has_trivial_destructor< void >
 
struct  has_trivial_destructor< void const >
 
struct  has_trivial_destructor< void const volatile >
 
struct  has_trivial_destructor< void volatile >
 
struct  has_nothrow_destructor_imp< T, b >
 
struct  has_nothrow_destructor_imp< T, true >
 
struct  has_nothrow_destructor< T >
 
struct  has_nothrow_destructor< T[N]>
 
struct  has_nothrow_destructor< T & >
 
struct  has_nothrow_destructor< T && >
 
struct  has_trivial_constructor< T >
 
struct  has_trivial_constructor< void >
 
struct  has_trivial_constructor< void const >
 
struct  has_trivial_constructor< void const volatile >
 
struct  has_trivial_constructor< void volatile >
 
struct  has_trivial_default_constructor< T >
 
struct  has_trivial_copy< T >
 
struct  has_trivial_copy< T[N]>
 
struct  has_trivial_copy< T[]>
 
struct  has_trivial_copy< T volatile >
 
struct  has_trivial_copy< void >
 
struct  has_trivial_copy< void const >
 
struct  has_trivial_copy< void volatile >
 
struct  has_trivial_copy< void const volatile >
 
struct  has_trivial_copy< T & >
 
struct  has_trivial_copy< T && >
 
struct  has_trivial_copy_constructor< T >
 
struct  has_trivial_move_assign< T >
 
struct  has_trivial_move_assign< void >
 
struct  has_trivial_move_assign< void const >
 
struct  has_trivial_move_assign< void const volatile >
 
struct  has_trivial_move_assign< void volatile >
 
struct  has_trivial_move_assign< T & >
 
struct  has_trivial_move_assign< T && >
 
struct  has_trivial_move_assign< T[N]>
 
struct  has_trivial_move_assign< T[]>
 
struct  has_trivial_move_constructor< T >
 
struct  has_trivial_move_constructor< void >
 
struct  has_trivial_move_constructor< void const >
 
struct  has_trivial_move_constructor< void volatile >
 
struct  has_trivial_move_constructor< void const volatile >
 
struct  has_trivial_move_constructor< T & >
 
struct  has_trivial_move_constructor< T && >
 
struct  has_trivial_move_constructor< T[N]>
 
struct  has_trivial_move_constructor< T[]>
 
struct  has_virtual_destructor< T >
 
struct  is_complex< T >
 
struct  is_complex< const T >
 
struct  is_complex< volatile const T >
 
struct  is_complex< volatile T >
 
struct  is_complex< std::complex< T > >
 
struct  is_compound< T >
 
struct  is_copy_assignable_impl2< DerivedFromNoncopyable, T >
 
struct  is_copy_assignable_impl2< true, T >
 
struct  is_copy_assignable_impl< T >
 
struct  is_copy_assignable< T >
 
struct  is_copy_assignable< void >
 
struct  is_copy_assignable< void const >
 
struct  is_copy_assignable< void const volatile >
 
struct  is_copy_assignable< void volatile >
 
struct  empty_helper_t1< T >
 
struct  empty_helper_t2
 
struct  empty_helper< T, is_a_class >
 
struct  empty_helper< T, true >
 
struct  is_empty_impl< T >
 
struct  is_empty< T >
 
struct  is_final< T >
 
struct  is_float< T >
 
struct  is_member_object_pointer< T >
 
struct  false_or_cpp11_noexcept_move_assignable< T, Enable >
 
struct  false_or_cpp11_noexcept_move_assignable< T, typename ::boost::enable_if_c< sizeof(T) &&BOOST_NOEXCEPT_EXPR(::boost::declval< T & >()=::boost::declval< T >())>::type >
 
struct  is_nothrow_move_assignable< T >
 
struct  is_nothrow_move_assignable< T const >
 
struct  is_nothrow_move_assignable< T const volatile >
 
struct  is_nothrow_move_assignable< T volatile >
 
struct  is_nothrow_move_assignable< T & >
 
struct  is_nothrow_move_assignable< T && >
 
struct  is_nothrow_move_assignable< void >
 
struct  is_nothrow_move_assignable< void const >
 
struct  is_nothrow_move_assignable< void const volatile >
 
struct  is_nothrow_move_assignable< void volatile >
 
struct  false_or_cpp11_noexcept_move_constructible< T, Enable >
 
struct  false_or_cpp11_noexcept_move_constructible< T, typename ::boost::enable_if_c< sizeof(T) &&BOOST_NOEXCEPT_EXPR(T(::boost::declval< T >()))>::type >
 
struct  is_nothrow_move_constructible< T >
 
struct  is_nothrow_move_constructible< volatile T >
 
struct  is_nothrow_move_constructible< const volatile T >
 
struct  is_nothrow_move_constructible< T[N]>
 
struct  is_nothrow_move_constructible< T[]>
 
struct  is_nothrow_move_constructible< void >
 
struct  is_nothrow_move_constructible< void const >
 
struct  is_nothrow_move_constructible< void volatile >
 
struct  is_nothrow_move_constructible< void const volatile >
 
struct  is_nothrow_move_constructible< T & >
 
struct  is_nothrow_move_constructible< T && >
 
struct  is_object< T >
 
struct  is_signed_values< T >
 
struct  is_signed_helper< T >
 
struct  is_signed_select_helper< integral_type >::rebind< T >
 
struct  is_signed_select_helper< integral_type >
 
struct  is_signed_select_helper< false >::rebind< T >
 
struct  is_signed_select_helper< false >
 
struct  is_signed_impl< T >
 
struct  is_signed< T >
 
struct  is_signed< signed char >
 
struct  is_signed< const signed char >
 
struct  is_signed< volatile signed char >
 
struct  is_signed< const volatile signed char >
 
struct  is_signed< short >
 
struct  is_signed< const short >
 
struct  is_signed< volatile short >
 
struct  is_signed< const volatile short >
 
struct  is_signed< int >
 
struct  is_signed< const int >
 
struct  is_signed< volatile int >
 
struct  is_signed< const volatile int >
 
struct  is_signed< long >
 
struct  is_signed< const long >
 
struct  is_signed< volatile long >
 
struct  is_signed< const volatile long >
 
struct  is_signed< unsigned char >
 
struct  is_signed< const unsigned char >
 
struct  is_signed< volatile unsigned char >
 
struct  is_signed< const volatile unsigned char >
 
struct  is_signed< unsigned short >
 
struct  is_signed< const unsigned short >
 
struct  is_signed< volatile unsigned short >
 
struct  is_signed< const volatile unsigned short >
 
struct  is_signed< unsigned int >
 
struct  is_signed< const unsigned int >
 
struct  is_signed< volatile unsigned int >
 
struct  is_signed< const volatile unsigned int >
 
struct  is_signed< unsigned long >
 
struct  is_signed< const unsigned long >
 
struct  is_signed< volatile unsigned long >
 
struct  is_signed< const volatile unsigned long >
 
struct  is_signed< char >
 
struct  is_signed< const char >
 
struct  is_signed< volatile char >
 
struct  is_signed< const volatile char >
 
struct  is_signed< wchar_t >
 
struct  is_signed< const wchar_t >
 
struct  is_signed< volatile wchar_t >
 
struct  is_signed< const volatile wchar_t >
 
struct  is_stateless< T >
 
struct  is_unsigned_values< T >
 
struct  is_ununsigned_helper< T >
 
struct  is_unsigned_select_helper< integral_type >::rebind< T >
 
struct  is_unsigned_select_helper< integral_type >
 
struct  is_unsigned_select_helper< false >::rebind< T >
 
struct  is_unsigned_select_helper< false >
 
struct  is_unsigned< T >
 
struct  is_unsigned< T >
 
struct  is_unsigned< unsigned char >
 
struct  is_unsigned< const unsigned char >
 
struct  is_unsigned< volatile unsigned char >
 
struct  is_unsigned< const volatile unsigned char >
 
struct  is_unsigned< unsigned short >
 
struct  is_unsigned< const unsigned short >
 
struct  is_unsigned< volatile unsigned short >
 
struct  is_unsigned< const volatile unsigned short >
 
struct  is_unsigned< unsigned int >
 
struct  is_unsigned< const unsigned int >
 
struct  is_unsigned< volatile unsigned int >
 
struct  is_unsigned< const volatile unsigned int >
 
struct  is_unsigned< unsigned long >
 
struct  is_unsigned< const unsigned long >
 
struct  is_unsigned< volatile unsigned long >
 
struct  is_unsigned< const volatile unsigned long >
 
struct  is_unsigned< signed char >
 
struct  is_unsigned< const signed char >
 
struct  is_unsigned< volatile signed char >
 
struct  is_unsigned< const volatile signed char >
 
struct  is_unsigned< short >
 
struct  is_unsigned< const short >
 
struct  is_unsigned< volatile short >
 
struct  is_unsigned< const volatile short >
 
struct  is_unsigned< int >
 
struct  is_unsigned< const int >
 
struct  is_unsigned< volatile int >
 
struct  is_unsigned< const volatile int >
 
struct  is_unsigned< long >
 
struct  is_unsigned< const long >
 
struct  is_unsigned< volatile long >
 
struct  is_unsigned< const volatile long >
 
struct  is_unsigned< char >
 
struct  is_unsigned< const char >
 
struct  is_unsigned< volatile char >
 
struct  is_unsigned< const volatile char >
 
struct  is_unsigned< wchar_t >
 
struct  is_unsigned< const wchar_t >
 
struct  is_unsigned< volatile wchar_t >
 
struct  is_unsigned< const volatile wchar_t >
 
struct  is_virtual_base_of_impl< Base, Derived, tag >
 
union  is_virtual_base_of_impl< Base, Derived, true_type >::max_align
 
struct  is_virtual_base_of_impl< Base, Derived, true_type >::boost_type_traits_internal_struct_X
 
struct  is_virtual_base_of_impl< Base, Derived, true_type >::boost_type_traits_internal_struct_Y
 
struct  is_virtual_base_of_impl< Base, Derived, true_type >
 
struct  is_virtual_base_of_impl2< Base, Derived >
 
struct  is_virtual_base_of< Base, Derived >
 
struct  is_virtual_base_of< Base &, Derived >
 
struct  is_virtual_base_of< Base, Derived & >
 
struct  is_virtual_base_of< Base &, Derived & >
 
struct  make_signed< T >
 
struct  make_unsigned< T >
 
struct  make_void<... >
 
struct  rank_imp< T, N >
 
struct  rank_imp< T[R], N >
 
struct  rank_imp< T const [R], N >
 
struct  rank_imp< T volatile[R], N >
 
struct  rank_imp< T const volatile[R], N >
 
struct  rank_imp< T[], N >
 
struct  rank_imp< T const [], N >
 
struct  rank_imp< T volatile[], N >
 
struct  rank_imp< T const volatile[], N >
 
struct  rank< T >
 
struct  remove_cv_ref< T >
 
struct  remove_volatile< T >
 
struct  remove_volatile< T volatile >
 
struct  remove_volatile< T volatile[N]>
 
struct  remove_volatile< T volatile[]>
 
struct  type_identity< T >
 
struct  need_promotion< T >
 
struct  need_promotion< char >
 
struct  need_promotion< signed char >
 
struct  need_promotion< unsigned char >
 
struct  need_promotion< signed short int >
 
struct  need_promotion< unsigned short int >
 
struct  need_promotion< wchar_t >
 
struct  need_promotion< bool >
 
struct  promote_from_index< Index, IsConst, IsVolatile >
 
struct  sized_type_for_promotion< N >
 
struct  promoted_index< T >
 
struct  integral_promotion_impl< T >
 
struct  integral_promotion< T, b >
 
struct  integral_promotion< T, true >
 
struct  integral_promotion< T >
 
struct  promote< T >
 
struct  promote_traits< X, Y >
 
struct  type_traits< T >
 
struct  scalar_traits< T >
 
struct  type_traits< float >
 
struct  type_traits< double >
 
struct  type_traits< long double >
 
struct  complex_traits< T >
 
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< S1, S2 >
 
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< IC >
 
struct  iterator_base_traits< std::forward_iterator_tag >::iterator_base< I, T >
 
struct  iterator_base_traits< std::forward_iterator_tag >
 
struct  iterator_base_traits< std::bidirectional_iterator_tag >::iterator_base< I, T >
 
struct  iterator_base_traits< std::bidirectional_iterator_tag >
 
struct  iterator_base_traits< sparse_bidirectional_iterator_tag >::iterator_base< I, T >
 
struct  iterator_base_traits< sparse_bidirectional_iterator_tag >
 
struct  iterator_base_traits< std::random_access_iterator_tag >::iterator_base< I, T >
 
struct  iterator_base_traits< std::random_access_iterator_tag >
 
struct  iterator_base_traits< packed_random_access_iterator_tag >::iterator_base< I, T >
 
struct  iterator_base_traits< packed_random_access_iterator_tag >
 
struct  iterator_base_traits< dense_random_access_iterator_tag >::iterator_base< I, T >
 
struct  iterator_base_traits< dense_random_access_iterator_tag >
 
struct  iterator_restrict_traits< I1, I2 >
 
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  has_trivial_constructor< T >
 
struct  has_trivial_destructor< T >
 
struct  has_trivial_constructor< std::complex< FLT > >
 
struct  has_trivial_destructor< std::complex< FLT > >
 
struct  container_view_traits< E >
 Traits class to extract type information from a constant matrix or vector CONTAINER. More...
 
struct  mutable_container_traits< E >
 Traits class to extract additional type information from a mutable matrix or vector CONTAINER. More...
 
struct  container_traits< E >
 Traits class to extract type information from a matrix or vector CONTAINER. More...
 
struct  matrix_view_traits< MATRIX >
 Traits class to extract type information from a constant MATRIX. More...
 
struct  mutable_matrix_traits< MATRIX >
 Traits class to extract additional type information from a mutable MATRIX. More...
 
struct  matrix_traits< MATRIX >
 Traits class to extract type information from a MATRIX. More...
 
struct  vector_view_traits< VECTOR >
 Traits class to extract type information from a VECTOR. More...
 
struct  mutable_vector_traits< VECTOR >
 Traits class to extract type information from a VECTOR. More...
 
struct  vector_traits< VECTOR >
 Traits class to extract type information from a VECTOR. More...
 
class  storage_array< E >
 
class  array_adaptor< T >
 
class  index_pair< V >
 
class  index_pair_array< V1, V2 >
 
class  index_triple< M >
 
class  index_triple_array< V1, V2, V3 >
 
struct  scalar_unary_functor< T >
 
struct  scalar_identity< T >
 
struct  scalar_negate< T >
 
struct  scalar_conj< T >
 
struct  scalar_real_unary_functor< T >
 
struct  scalar_real< T >
 
struct  scalar_imag< T >
 
struct  scalar_binary_functor< T1, T2 >
 
struct  scalar_plus< T1, T2 >
 
struct  scalar_minus< T1, T2 >
 
struct  scalar_multiplies< T1, T2 >
 
struct  scalar_divides< T1, T2 >
 
struct  scalar_binary_assign_functor< T1, T2 >
 
struct  assign_tag
 
struct  computed_assign_tag
 
struct  scalar_assign< T1, T2 >::rebind< U1, U2 >
 
struct  scalar_assign< T1, T2 >
 
struct  scalar_plus_assign< T1, T2 >::rebind< U1, U2 >
 
struct  scalar_plus_assign< T1, T2 >
 
struct  scalar_minus_assign< T1, T2 >::rebind< U1, U2 >
 
struct  scalar_minus_assign< T1, T2 >
 
struct  scalar_multiplies_assign< T1, T2 >::rebind< U1, U2 >
 
struct  scalar_multiplies_assign< T1, T2 >
 
struct  scalar_divides_assign< T1, T2 >::rebind< U1, U2 >
 
struct  scalar_divides_assign< T1, T2 >
 
struct  scalar_binary_swap_functor< T1, T2 >
 
struct  scalar_swap< T1, T2 >::rebind< U1, U2 >
 
struct  scalar_swap< T1, T2 >
 
struct  vector_scalar_unary_functor< V >
 
struct  vector_sum< V >
 
struct  vector_scalar_real_unary_functor< V >
 
struct  vector_norm_1< V >
 
struct  vector_norm_2< V >
 
struct  vector_norm_inf< V >
 
struct  vector_scalar_index_unary_functor< V >
 
struct  vector_index_norm_inf< V >
 
struct  vector_scalar_binary_functor< V1, V2, TV >
 
struct  vector_inner_prod< V1, V2, TV >
 
struct  matrix_vector_binary_functor< M1, M2, TV >
 
struct  matrix_vector_prod1< M1, M2, TV >
 
struct  matrix_vector_prod2< M1, M2, TV >
 
struct  matrix_matrix_binary_functor< M1, M2, TV >
 
struct  matrix_matrix_prod< M1, M2, TV >
 
struct  matrix_scalar_real_unary_functor< M >
 
struct  matrix_norm_1< M >
 
struct  matrix_norm_frobenius< M >
 
struct  matrix_norm_inf< M >
 
struct  transposed_structure< L >
 
class  ublas_expression< E >
 Base class for uBLAS statically derived expressions using the the Barton Nackman trick. More...
 
class  scalar_expression< E >
 Base class for Scalar Expression models. More...
 
class  scalar_reference< T >
 
class  scalar_value< T >
 
class  vector_unary< E, F >::const_iterator
 
class  vector_unary< E, F >
 
struct  vector_unary_traits< E, F >
 
class  vector_binary< E1, E2, F >::const_iterator
 
class  vector_binary< E1, E2, F >
 
struct  vector_binary_traits< E1, E2, F >
 
class  vector_binary_scalar1< E1, E2, F >::const_iterator
 
class  vector_binary_scalar1< E1, E2, F >
 
struct  vector_binary_scalar1_traits< E1, E2, F >
 
class  vector_binary_scalar2< E1, E2, F >::const_iterator
 
class  vector_binary_scalar2< E1, E2, F >
 
struct  vector_binary_scalar2_traits< E1, E2, F >
 
class  vector_scalar_unary< E, F >
 
struct  vector_scalar_unary_traits< E, F >
 
class  vector_scalar_binary< E1, E2, F >
 
struct  vector_scalar_binary_traits< E1, E2, F >
 
struct  vector_assign_traits< SC, COMPUTED, RI >
 
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< SC, RI >
 
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< E1, E2, F >::const_iterator1
 
class  vector_matrix_binary< E1, E2, F >::const_iterator2
 
class  vector_matrix_binary< E1, E2, F >
 
struct  vector_matrix_binary_traits< E1, E2, F >
 
class  matrix_unary1< E, F >::const_iterator1
 
class  matrix_unary1< E, F >::const_iterator2
 
class  matrix_unary1< E, F >
 
struct  matrix_unary1_traits< E, F >
 
class  matrix_unary2< E, F >::const_iterator1
 
class  matrix_unary2< E, F >::const_iterator2
 
class  matrix_unary2< E, F >
 
struct  matrix_unary2_traits< E, F >
 
class  matrix_binary< E1, E2, F >::const_iterator1
 
class  matrix_binary< E1, E2, F >::const_iterator2
 
class  matrix_binary< E1, E2, F >
 
struct  matrix_binary_traits< E1, E2, F >
 
class  matrix_binary_scalar1< E1, E2, F >::const_iterator1
 
class  matrix_binary_scalar1< E1, E2, F >::const_iterator2
 
class  matrix_binary_scalar1< E1, E2, F >
 
struct  matrix_binary_scalar1_traits< E1, E2, F >
 
class  matrix_binary_scalar2< E1, E2, F >::const_iterator1
 
class  matrix_binary_scalar2< E1, E2, F >::const_iterator2
 
class  matrix_binary_scalar2< E1, E2, F >
 
struct  matrix_binary_scalar2_traits< E1, E2, F >
 
class  matrix_vector_binary1< E1, E2, F >::const_iterator
 
class  matrix_vector_binary1< E1, E2, F >
 
struct  matrix_vector_binary1_traits< T1, E1, T2, E2 >
 
class  matrix_vector_binary2< E1, E2, F >::const_iterator
 
class  matrix_vector_binary2< E1, E2, F >
 
struct  matrix_vector_binary2_traits< T1, E1, T2, E2 >
 
class  matrix_matrix_binary< E1, E2, F >::const_iterator1
 
class  matrix_matrix_binary< E1, E2, F >::const_iterator2
 
class  matrix_matrix_binary< E1, E2, F >
 
struct  matrix_matrix_binary_traits< T1, E1, T2, E2 >
 
class  matrix_scalar_unary< E, F >
 
struct  matrix_scalar_unary_traits< E, F >
 
struct  matrix_assign_traits< SC, COMPUTED, RI1, RI2 >
 
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< SC, RI1, RI2 >
 
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< M >
 For the creation of temporary vectors in the assignment of proxies. More...
 
struct  matrix_temporary_traits< M >
 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< E1, E2 >
 
struct  matrix_matrix_solve_traits< E1, E2 >
 
class  permutation_matrix< T, A >
 
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 > >
 
class  Matrix
 Implementation of Matrixwrapper using Boost. More...
 
class  SymmetricMatrix
 
class  ColumnVector
 Wrapper class for ColumnVectors (Boost implementation) More...
 
class  RowVector
 Wrapper class for RowVectors (Boost implementation) More...
 
class  Sample< T >
 
class  WeightedSample< T >
 

Macros

#define __PTHREAD_RWLOCK_ELISION_EXTRA   0
 
#define __PTHREAD_MUTEX_HAVE_PREV   0
 
#define PTHREAD_CREATE_JOINABLE   PTHREAD_CREATE_JOINABLE
 
#define PTHREAD_CREATE_DETACHED   PTHREAD_CREATE_DETACHED
 
#define PTHREAD_INHERIT_SCHED   PTHREAD_INHERIT_SCHED
 
#define PTHREAD_EXPLICIT_SCHED   PTHREAD_EXPLICIT_SCHED
 
#define PTHREAD_SCOPE_SYSTEM   PTHREAD_SCOPE_SYSTEM
 
#define PTHREAD_SCOPE_PROCESS   PTHREAD_SCOPE_PROCESS
 
#define PTHREAD_PROCESS_PRIVATE   PTHREAD_PROCESS_PRIVATE
 
#define PTHREAD_PROCESS_SHARED   PTHREAD_PROCESS_SHARED
 
#define PTHREAD_CANCEL_ENABLE   PTHREAD_CANCEL_ENABLE
 
#define PTHREAD_CANCEL_DISABLE   PTHREAD_CANCEL_DISABLE
 
#define PTHREAD_CANCEL_DEFERRED   PTHREAD_CANCEL_DEFERRED
 
#define PTHREAD_CANCEL_ASYNCHRONOUS   PTHREAD_CANCEL_ASYNCHRONOUS
 
#define BOOST_TT_CXX11_IS_CONVERTIBLE
 
#define BOOST_OPERATOR2_LEFT(name)   name##2##_##left
 
#define BOOST_BINARY_OPERATOR_COMMUTATIVE(NAME, OP)
 
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE(NAME, OP)
 
#define BOOST_BINARY_OPERATOR(NAME, OP)
 
#define BOOST_OPERATOR_TEMPLATE4(template_name4)
 
#define BOOST_OPERATOR_TEMPLATE3(template_name3)
 
#define BOOST_OPERATOR_TEMPLATE2(template_name2)
 
#define BOOST_OPERATOR_TEMPLATE1(template_name1)
 
#define BOOST_OPERATOR_TEMPLATE(template_name)
 
#define BOOST_UBLAS_CHECK_FALSE(e)
 
#define BOOST_UBLAS_CHECK(expression, e)
 
#define BOOST_UBLAS_CHECK_EX(expression, file, line, e)
 
#define BOOST_UBLAS_SAME(size1, size2)   same_impl_ex ((size1), (size2), __FILE__, __LINE__)
 
#define AUX778076_IMPL_SPEC(name, tag, result)
 
#define AUX_CLASS_SEQUENCE_TAG_SPEC(has_tag, has_begin, result_type)
 
#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T)
 
#define BOOST_TT_AUX_PROMOTE_FROM_INDEX(N, T)
 
#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I, T)   sized_type_for_promotion<I>::type promoted_index_tester(T);
 

Typedefs

typedef void(* new_handler) ()
 
typedef mpl::integral_c_tag tag
 
typedef T value_type
 
typedef integral_constant< T, val > type
 
typedef mpl::integral_c_tag tag
 
typedef bool value_type
 
typedef integral_constant< bool, val > type
 
typedef integral_constant< bool, true > true_type
 
typedef integral_constant< bool, false > false_type
 
typedef T & type
 
typedef T && type
 
typedef boost::detail::add_reference_impl< T >::type type
 
typedef T & type
 
typedef void type
 
typedef const void type
 
typedef const volatile void type
 
typedef volatile void type
 
template<class T >
using add_reference_t = typename add_reference< T >::type
 
typedef char yes_type
 
typedef is_abstract_imp2< T > type
 
typedef false_type type
 
typedef is_abstract_select< ::boost::is_class< T >::value > selector
 
typedef selector::template rebind< T > binder
 
typedef binder::type type
 
typedef boost::add_reference< T >::type type
 
typedef T & type
 
template<class T >
using add_lvalue_reference_t = typename add_lvalue_reference< T >::type
 
typedef T type
 
typedef T && type
 
typedef boost::type_traits_detail::add_rvalue_reference_helper< T,(is_void< T >::value==false &&is_reference< T >::value==false) >::type type
 
typedef boost::type_traits_detail::add_rvalue_reference_imp< T >::type type
 
template<class T >
using add_rvalue_reference_t = typename add_rvalue_reference< T >::type
 
typedef is_convertible_impl< From, To > type
 
typedef true_type type
 
typedef false_type type
 
typedef false_type type
 
typedef is_convertible_impl_select< ::boost::is_arithmetic< From >::value, ::boost::is_arithmetic< To >::value, false > selector
 
typedef selector::template rebind< From, To > isc_binder
 
typedef isc_binder::type type
 
typedef ::boost::detail::is_enum_helper< selector > se_t
 
typedef se_t::template type< T > helper
 
typedef T type
 
typedef T type
 
typedef T type
 
typedef T type
 
typedef T type[N]
 
typedef T type[N]
 
typedef T type[N]
 
typedef T type[]
 
typedef T type[]
 
typedef T type[]
 
template<class T >
using remove_cv_t = typename remove_cv< T >::type
 
typedef is_base_and_derived_impl3< T, U > type
 
typedef is_base_and_derived_impl2< T, U > type
 
typedef remove_cv< B >::type ncvB
 
typedef remove_cv< D >::type ncvD
 
typedef is_base_and_derived_select< ::boost::is_class< B >::value, ::boost::is_class< D >::value, ::boost::is_same< ncvB, ncvD >::value > selector
 
typedef selector::template rebind< ncvB, ncvD > binder
 
typedef binder::type bound_type
 
typedef T::value_type type
 
typedef integral_c_tag tag
 
typedef bool_ type
 
typedef bool value_type
 
typedef na type
 
typedef T type
 
typedef U type
 
typedef AUX_WRAPPER_NAME type
 
typedef AUX_WRAPPER_VALUE_TYPE value_type
 
typedef integral_c_tag tag
 
typedef T1 type
 
typedef T2 type
 
typedef almost_type_::type type
 
typedef AUX_WRAPPER_NAME type
 
typedef AUX_WRAPPER_VALUE_TYPE value_type
 
typedef integral_c_tag tag
 
typedef integral_c_tag tag
 
typedef integral_c type
 
typedef bool value_type
 
typedef U::level type
 
typedef mpl::integral_c_tag tag
 
typedef mpl::eval_if< is_base_and_derived< boost::serialization::basic_traits, T >, traits_class_level< T >, typename mpl::eval_if< is_fundamental< T >, mpl::int_< primitive_type >, typename mpl::eval_if< is_class< T >, mpl::int_< object_class_info >, typename mpl::eval_if< is_array< T >, mpl::int_< object_serializable >, typename mpl::eval_if< is_enum< T >, mpl::int_< primitive_type >, mpl::int_< not_serializable > > > > > >::type type
 
typedef T type
 
typedef identity< T > type
 
typedef T type
 
typedef T type
 
typedef char(& no_tag)[1]
 
typedef char(& yes_tag)[2]
 
typedef no_tag type
 
typedef yes_tag type
 
typedef char(& type)[n]
 
typedef void_ type
 
typedef T::tag type
 
typedef T type
 
typedef msvc_eti_base type
 
typedef msvc_eti_base first
 
typedef msvc_eti_base second
 
typedef msvc_eti_base tag
 
typedef mpl::int_< Level > level
 
typedef mpl::int_< Tracking > tracking
 
typedef mpl::int_< Version > version
 
typedef ETII type_info_implementation
 
typedef Wrapper is_wrapper
 
typedef U::type_info_implementation::type type
 
typedef mpl::eval_if< is_base_and_derived< boost::serialization::basic_traits, T >, traits_class_typeinfo_implementation< T >, mpl::identity< typename extended_type_info_impl< T >::type > >::type type
 
typedef U::tracking type
 
typedef mpl::integral_c_tag tag
 
typedef mpl::eval_if< is_base_and_derived< boost::serialization::basic_traits, T >, traits_class_tracking< T >, typename mpl::eval_if< is_pointer< T >, mpl::int_< track_never >, typename mpl::eval_if< typename mpl::equal_to< implementation_level< T >, mpl::int_< primitive_type > >, mpl::int_< track_never >, mpl::int_< track_selectively > > > >::type type
 
typedef is_polymorphic_imp2< T > type
 
typedef is_polymorphic_imp1< T > type
 
typedef is_polymorphic_selector< ::boost::is_class< T >::value > selector
 
typedef selector::template rebind< T > binder
 
typedef binder::type imp_type
 
typedef mpl::if_< is_const< D >, const B, B >::type type
 
typedef is_wrapper_impl< const T >::type type
 
typedef std::nullptr_t addressof_null_t
 
typedef addressof_null_t type
 
typedef const addressof_null_t type
 
typedef volatile addressof_null_t type
 
typedef const volatile addressof_null_t type
 
typedef void type
 
typedef T * type
 
typedef mpl::integral_c_tag tag
 
typedef mpl::int_< object_serializable > type
 
typedef mpl::integral_c_tag tag
 
typedef mpl::int_< track_never > type
 
typedef operators_detail::false_t value
 
typedef Category iterator_category
 
typedef T value_type
 
typedef Distance difference_type
 
typedef Pointer pointer
 
typedef Reference reference
 
typedef T type
 
typedef T type
 
typedef boost::detail::remove_rvalue_ref< T >::type type
 
typedef T type
 
template<class T >
using remove_reference_t = typename remove_reference< T >::type
 
typedef T type
 
template<class T >
using remove_all_extents_t = typename remove_all_extents< T >::type
 
typedef Value type
 
typedef void * type
 
typedef int type
 
typedef void * type
 
typedef P::type p_type
 
typedef assert_arg_pred_impl< p_type::value >::type type
 
typedef P::type p_type
 
typedef assert_arg_pred_impl< p >::type type
 
typedef T::next type
 
typedef T::prior type
 
typedef protect type
 
typedef T type
 
typedef T type
 
typedef T type[N]
 
typedef T type[]
 
template<class T >
using remove_const_t = typename remove_const< T >::type
 
typedef noncopyable_::noncopyable noncopyable
 
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
 
typedef C::closure_type closure_type
 
typedef C container_type
 
typedef C container_type
 
typedef I derived_iterator_type
 
typedef T derived_value_type
 
typedef I derived_iterator_type
 
typedef T derived_value_type
 
typedef I derived_iterator_type
 
typedef T derived_value_type
 
typedef D derived_difference_type
 
typedef I::container_type container_type
 
typedef container_type::size_type size_type
 
typedef I::difference_type difference_type
 
typedef I iterator_type
 
typedef I::container_type container_type
 
typedef container_type::size_type size_type
 
typedef I::difference_type difference_type
 
typedef I iterator_type
 
typedef I::dual_iterator_type dual_iterator_type
 
typedef I::dual_reverse_iterator_type dual_reverse_iterator_type
 
typedef I::container_type container_type
 
typedef container_type::size_type size_type
 
typedef I::difference_type difference_type
 
typedef I iterator_type
 
typedef I::dual_iterator_type dual_iterator_type
 
typedef I::dual_reverse_iterator_type dual_reverse_iterator_type
 
typedef C container_type
 
typedef IC iterator_category
 
typedef container_type::size_type size_type
 
typedef container_type::difference_type difference_type
 
typedef container_type::value_type value_type
 
typedef container_type::reference reference
 
typedef C container_type
 
typedef IC iterator_category
 
typedef container_type::size_type size_type
 
typedef container_type::difference_type difference_type
 
typedef container_type::value_type value_type
 
typedef container_type::const_reference reference
 
typedef indexed_iterator< container_type, iterator_category > iterator_type
 
typedef C container_type
 
typedef IC iterator_category
 
typedef container_type::size_type size_type
 
typedef container_type::difference_type difference_type
 
typedef container_type::value_type value_type
 
typedef container_type::reference reference
 
typedef indexed_iterator2< container_type, iterator_category > dual_iterator_type
 
typedef reverse_iterator_base2< dual_iterator_typedual_reverse_iterator_type
 
typedef C container_type
 
typedef IC iterator_category
 
typedef container_type::size_type size_type
 
typedef container_type::difference_type difference_type
 
typedef container_type::value_type value_type
 
typedef container_type::const_reference reference
 
typedef indexed_iterator1< container_type, iterator_category > iterator_type
 
typedef indexed_const_iterator2< container_type, iterator_category > dual_iterator_type
 
typedef reverse_iterator_base2< dual_iterator_typedual_reverse_iterator_type
 
typedef C container_type
 
typedef IC iterator_category
 
typedef container_type::size_type size_type
 
typedef container_type::difference_type difference_type
 
typedef container_type::value_type value_type
 
typedef container_type::reference reference
 
typedef indexed_iterator1< container_type, iterator_category > dual_iterator_type
 
typedef reverse_iterator_base1< dual_iterator_typedual_reverse_iterator_type
 
typedef C container_type
 
typedef IC iterator_category
 
typedef container_type::size_type size_type
 
typedef container_type::difference_type difference_type
 
typedef container_type::value_type value_type
 
typedef container_type::const_reference reference
 
typedef indexed_iterator2< container_type, iterator_category > iterator_type
 
typedef indexed_const_iterator1< container_type, iterator_category > dual_iterator_type
 
typedef reverse_iterator_base1< dual_iterator_typedual_reverse_iterator_type
 
typedef AUX_WRAPPER_NAME type
 
typedef AUX_WRAPPER_VALUE_TYPE value_type
 
typedef integral_c_tag tag
 
typedef Vector::item0 type
 
typedef Vector::back type
 
typedef forward_iterator_tag type
 
typedef bidirectional_iterator_tag type
 
typedef random_access_iterator_tag type
 
typedef aux::v_iter_tag tag
 
typedef random_access_iterator_tag category
 
typedef v_at< Vector, n_ >::type type
 
typedef Vector vector_
 
typedef mpl::long_< n_ > pos
 
typedef v_iter< Vector,(n_+1)> type
 
typedef v_iter< Vector,(n_ - 1)> type
 
typedef v_iter< Vector,(n_+BOOST_MPL_AUX_NESTED_VALUE_WKND(long, Distance)) > type
 
typedef aux::vector_tag< 0 > tag
 
typedef vector0 type
 
typedef void_ item0
 
typedef v_iter< vector0<>, 0 > begin
 
typedef v_iter< vector0<>, 0 > end
 
typedef vector0 type
 
typedef Sequence::begin type
 
typedef Sequence::end type
 
typedef eval_if< aux::has_begin< Sequence, true_ >, aux::begin_type< Sequence >, void_ >::type type
 
typedef eval_if< aux::has_begin< Sequence, true_ >, aux::end_type< Sequence >, void_ >::type type
 
typedef sequence_tag< Sequence >::type tag_
 
typedef begin_impl< tag_ >::template apply< Sequence >::type type
 
typedef sequence_tag< Sequence >::type tag_
 
typedef end_impl< tag_ >::template apply< Sequence >::type type
 
typedef T::tag type
 
typedef less< N, long_< 0 > >::type backward_
 
typedef if_< backward_, negate< N >, N >::type offset_
 
typedef if_< backward_, aux::advance_backward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value >, aux::advance_forward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value > >::type f_
 
typedef apply_wrap1< f_, Iterator >::type type
 
typedef T::type type
 
typedef int type
 
typedef Iterator::type type
 
typedef advance< typename begin< Sequence >::type, N >::type iter_
 
typedef deref< iter_ >::type type
 
typedef R type
 
typedef T type
 
typedef T::type type
 
typedef T type
 
typedef T::type type
 
typedef char(& bool_value_type)[1]
 
typedef char(& float_value_type)[2]
 
typedef char(& double_value_type)[3]
 
typedef char(& long_double_value_type)[4]
 
typedef char(& char_value_type)[5]
 
typedef char(& schar_value_type)[6]
 
typedef char(& uchar_value_type)[7]
 
typedef char(& short_value_type)[8]
 
typedef char(& ushort_value_type)[9]
 
typedef char(& int_value_type)[10]
 
typedef char(& uint_value_type)[11]
 
typedef char(& long_value_type)[12]
 
typedef char(& ulong_value_type)[13]
 
typedef char(& x_value_type)[14]
 
typedef char(& y_value_type)[15]
 
typedef char(& cant_deduce_type)[16]
 
typedef remove_cv< X >::type x_type
 
typedef remove_cv< Y >::type y_type
 
typedef mpl::vector16< mpl::identity< bool >, mpl::identity< float >, mpl::identity< double >, mpl::identity< long double >, mpl::identity< char >, mpl::identity< signed char >, mpl::identity< unsigned char >, mpl::identity< short >, mpl::identity< unsigned short >, mpl::identity< int >, mpl::identity< unsigned int >, mpl::identity< long >, mpl::identity< unsigned long >, mpl::identity< x_type >, mpl::identity< y_type >, mpl::identity< error_cant_deduce_type > > types
 
typedef T const type
 
typedef T & type
 
template<class T >
using add_const_t = typename add_const< T >::type
 
typedef T const volatile type
 
typedef T & type
 
template<class T >
using add_cv_t = typename add_cv< T >::type
 
typedef remove_reference< T >::type no_ref_type
 
typedef no_ref_type * type
 
template<class T >
using add_pointer_t = typename add_pointer< T >::type
 
typedef T volatile type
 
typedef T & type
 
template<class T >
using add_volatile_t = typename add_volatile< T >::type
 
typedef long double type
 
typedef boost::detail::max_align type
 
typedef double type
 
typedef long type
 
typedef int type
 
typedef short type
 
typedef char type
 
typedef T type
 
typedef U type
 
template<bool b, class T , class U >
using conditional_t = typename conditional< b, T, U >::type
 
typedef ::boost::detail::aligned_storage::aligned_storage_imp< size_, alignment_ > type
 
typedef T type
 
typedef T type
 
typedef T const type
 
typedef T volatile type
 
typedef T const volatile type
 
typedef T type
 
typedef T const type
 
typedef T volatile type
 
typedef T const volatile type
 
template<class T >
using remove_extent_t = typename remove_extent< T >::type
 
template<class T >
using remove_bounds_t = typename remove_bounds< T >::type
 
typedef remove_cv< T >::type type
 
typedef remove_bounds< T >::type * type
 
typedef T * type
 
typedef boost::detail::decay_imp< Ty, boost::is_array< Ty >::value, boost::is_function< Ty >::value >::type type
 
template<class T >
using decay_t = typename decay< T >::type
 
using type = decltype(check_s< F >(0))
 
template<template< class... > class F, class... T>
using mp_valid = typename mp_valid_impl< F, T... >::type
 
using type = F< T... >
 
template<template< class... > class F, class... T>
using mp_defer = typename boost::conditional< mp_valid< F, T... >::value, mp_defer_impl< F, T... >, mp_empty >::type
 
template<class... T>
using common_type_t = typename common_type< T... >::type
 
template<class T1 , class T2 , class... T>
using common_type_fold = common_type_t< common_type_t< T1, T2 >, T... >
 
template<class T1 , class T2 >
using builtin_common_type = typename boost::decay< decltype(boost::declval< bool >()? boost::declval< T1 >():boost::declval< T2 >())>::type
 
typedef boost::conditional< boost::is_volatile< U >::value, typename boost::add_volatile< CT >::type, CT >::type type
 
template<class T , class U >
using copy_cv_t = typename copy_cv< T, U >::type
 
typedef T type
 
typedef double type
 
typedef double const type
 
typedef double volatile type
 
typedef double const volatile type
 
template<class T >
using floating_point_promotion_t = typename floating_point_promotion< T >::type
 
typedef R result_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T1 argument_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T1 first_argument_type
 
typedef T2 second_argument_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef T5 arg5_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef T5 arg5_type
 
typedef T6 arg6_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef T5 arg5_type
 
typedef T6 arg6_type
 
typedef T7 arg7_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef T5 arg5_type
 
typedef T6 arg6_type
 
typedef T7 arg7_type
 
typedef T8 arg8_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef T5 arg5_type
 
typedef T6 arg6_type
 
typedef T7 arg7_type
 
typedef T8 arg8_type
 
typedef T9 arg9_type
 
typedef R result_type
 
typedef T1 arg1_type
 
typedef T2 arg2_type
 
typedef T3 arg3_type
 
typedef T4 arg4_type
 
typedef T5 arg5_type
 
typedef T6 arg6_type
 
typedef T7 arg7_type
 
typedef T8 arg8_type
 
typedef T9 arg9_type
 
typedef T10 arg10_type
 
typedef remove_cv< B >::type ncvB
 
typedef remove_cv< D >::type ncvD
 
typedef T type
 
typedef T type
 
typedef T type
 
typedef T type
 
typedef T type
 
template<class T >
using remove_pointer_t = typename remove_pointer< T >::type
 
typedef boost::type_traits::yes_type yes_type
 
typedef boost::type_traits::no_type no_type
 
typedef remove_cv< T >::type cvt
 
typedef remove_cv< T >::type no_cv_t
 
typedef remove_cv< T >::type no_cv_t
 
typedef is_signed_helper< T > type
 
typedef false_type type
 
typedef ::boost::detail::is_signed_select_helper< ::boost::is_integral< T >::value||::boost::is_enum< T >::value > selector
 
typedef selector::template rebind< T > binder
 
typedef binder::type type
 
typedef remove_cv< T >::type no_cv_t
 
typedef is_ununsigned_helper< T > type
 
typedef false_type type
 
typedef ::boost::detail::is_unsigned_select_helper< ::boost::is_integral< T >::value||::boost::is_enum< T >::value > selector
 
typedef selector::template rebind< T > binder
 
typedef binder::type type
 
typedef boost::integral_constant< bool,(boost::is_base_of< Base, Derived >::value &&! boost::is_same< Base, Derived >::value)> tag_type
 
typedef is_virtual_base_of_impl< Base, Derived, tag_typeimp
 
typedef conditional< is_volatile< T >::value, typename add_volatile< const_base_integer_type >::type, const_base_integer_type >::type type
 
template<class T >
using make_signed_t = typename make_signed< T >::type
 
typedef conditional< is_volatile< T >::value, typename add_volatile< const_base_integer_type >::type, const_base_integer_type >::type type
 
template<class T >
using make_unsigned_t = typename make_unsigned< T >::type
 
typedef void type
 
template<class... Ts>
using void_t = typename make_void< Ts... >::type
 
template<class T >
using remove_cv_ref_t = typename remove_cv_ref< T >::type
 
typedef T type
 
typedef T type
 
typedef T type[N]
 
typedef T type[]
 
template<class T >
using remove_volatile_t = typename remove_volatile< T >::type
 
typedef T type
 
template<class T >
using type_identity_t = typename type_identity< T >::type
 
typedef char(& type)[N]
 
typedef BOOST_DEDUCED_TYPENAME promote_from_index<(boost::type_traits::detail::promoted_index< T >::value),(boost::is_const< T >::value),(boost::is_volatile< T >::value) >::type type
 
typedef T type
 
typedef boost::type_traits::detail::integral_promotion< T, tag_type::value >::type type
 
template<class T >
using integral_promotion_t = typename integral_promotion< T >::type
 
template<class T >
using promote_t = typename promote< T >::type
 
template<typename T >
using remove_cv_ref_t = typename remove_cv< typename remove_reference< T >::type >::type
 
typedef type_deduction_detail::base_result_of< X, Y > base_type
 
typedef mpl::at_c< typename base_type::types, index >::type id
 
typedef id::type promote_type
 
typedef scalar_traits< T > self_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef T real_type
 
typedef real_type precision_type
 
typedef type_traits< T > self_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef T real_type
 
typedef real_type precision_type
 
typedef type_traits< float > self_type
 
typedef float value_type
 
typedef const value_type & const_reference
 
typedef value_type & reference
 
typedef value_type real_type
 
typedef double precision_type
 
typedef type_traits< double > self_type
 
typedef double value_type
 
typedef const value_type & const_reference
 
typedef value_type & reference
 
typedef value_type real_type
 
typedef long double precision_type
 
typedef type_traits< long double > self_type
 
typedef long double value_type
 
typedef const value_type & const_reference
 
typedef value_type & reference
 
typedef value_type real_type
 
typedef value_type precision_type
 
typedef complex_traits< T > self_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef T::value_type real_type
 
typedef real_type precision_type
 
typedef type_traits< std::complex< float > > self_type
 
typedef std::complex< float > value_type
 
typedef const value_type & const_reference
 
typedef value_type & reference
 
typedef float real_type
 
typedef std::complex< double > precision_type
 
typedef type_traits< std::complex< double > > self_type
 
typedef std::complex< double > value_type
 
typedef const value_type & const_reference
 
typedef value_type & reference
 
typedef double real_type
 
typedef std::complex< long double > precision_type
 
typedef type_traits< std::complex< long double > > self_type
 
typedef std::complex< long double > value_type
 
typedef const value_type & const_reference
 
typedef value_type & reference
 
typedef long double real_type
 
typedef value_type precision_type
 
typedef S1 storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef packed_proxy_tag storage_category
 
typedef packed_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef dense_proxy_tag storage_category
 
typedef packed_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef packed_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef forward_iterator_base< std::forward_iterator_tag, I, T > type
 
typedef bidirectional_iterator_base< std::bidirectional_iterator_tag, I, T > type
 
typedef bidirectional_iterator_base< sparse_bidirectional_iterator_tag, I, T > type
 
typedef random_access_iterator_base< std::random_access_iterator_tag, I, T > type
 
typedef random_access_iterator_base< packed_random_access_iterator_tag, I, T > type
 
typedef random_access_iterator_base< dense_random_access_iterator_tag, I, T > type
 
typedef I1 iterator_category
 
typedef sparse_bidirectional_iterator_tag iterator_category
 
typedef sparse_bidirectional_iterator_tag iterator_category
 
typedef sparse_bidirectional_iterator_tag iterator_category
 
typedef sparse_bidirectional_iterator_tag iterator_category
 
typedef packed_random_access_iterator_tag iterator_category
 
typedef packed_random_access_iterator_tag iterator_category
 
typedef E::size_type size_type
 type of indices
 
typedef E::difference_type difference_type
 type of differences of indices
 
typedef E::storage_category storage_category
 storage category: unknown_storage_tag, dense_tag, packed_tag, ...
 
typedef E::value_type value_type
 type of elements
 
typedef E::const_reference const_reference
 const reference to an element
 
typedef E::const_closure_type const_closure_type
 type used in expressions to mark a reference to this class (usually a const container_reference<const E> or the class itself)
 
typedef E::reference reference
 reference to an element
 
typedef E::closure_type closure_type
 type used in expressions to mark a reference to this class (usually a container_reference<E> or the class itself)
 
typedef MATRIX::orientation_category orientation_category
 orientation of the matrix, either row_major_tag, column_major_tag or unknown_orientation_tag
 
typedef MATRIX::const_iterator1 const_iterator1
 row iterator for the matrix
 
typedef MATRIX::const_iterator2 const_iterator2
 column iterator for the matrix
 
typedef MATRIX::iterator1 iterator1
 row iterator for the matrix
 
typedef MATRIX::iterator2 iterator2
 column iterator for the matrix
 
typedef VECTOR::const_iterator const_iterator
 iterator for the VECTOR
 
typedef VECTOR::iterator iterator
 iterator for the VECTOR
 
typedef ALLOC allocator_type
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const T * const_pointer
 
typedef T * pointer
 
typedef const_pointer const_iterator
 
typedef pointer iterator
 
typedef std::reverse_iterator< const_iterator > const_reverse_iterator
 
typedef std::reverse_iterator< iterator > reverse_iterator
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const T * const_pointer
 
typedef T * pointer
 
typedef const_pointer const_iterator
 
typedef pointer iterator
 
typedef std::reverse_iterator< const_iterator > const_reverse_iterator
 
typedef std::reverse_iterator< iterator > reverse_iterator
 
typedef std::size_t size_type
 
typedef std::ptrdiff_t difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const T * const_pointer
 
typedef T * pointer
 
typedef const_pointer const_iterator
 
typedef pointer iterator
 
typedef std::reverse_iterator< const_iterator > const_reverse_iterator
 
typedef std::reverse_iterator< iterator > reverse_iterator
 
typedef Z size_type
 
typedef D difference_type
 
typedef size_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const value_type * const_pointer
 
typedef value_type * pointer
 
typedef basic_range::value_type value_type
 
typedef basic_range::difference_type difference_type
 
typedef basic_range::const_reference reference
 
typedef basic_range::const_pointer pointer
 
typedef std::reverse_iterator< const_iteratorconst_reverse_iterator
 
typedef Z size_type
 
typedef D difference_type
 
typedef size_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const value_type * const_pointer
 
typedef value_type * pointer
 
typedef basic_slice::value_type value_type
 
typedef basic_slice::difference_type difference_type
 
typedef basic_slice::const_reference reference
 
typedef basic_slice::const_pointer pointer
 
typedef std::reverse_iterator< const_iteratorconst_reverse_iterator
 
typedef A array_type
 
typedef const A const_array_type
 
typedef A::size_type size_type
 
typedef A::difference_type difference_type
 
typedef A::value_type value_type
 
typedef A::const_reference const_reference
 
typedef A::reference reference
 
typedef A::const_pointer const_pointer
 
typedef A::pointer pointer
 
typedef indirect_array::value_type value_type
 
typedef indirect_array::difference_type difference_type
 
typedef indirect_array::const_reference reference
 
typedef indirect_array::const_pointer pointer
 
typedef std::reverse_iterator< const_iteratorconst_reverse_iterator
 
typedef V::size_type size_type
 
typedef V1::value_type value1_type
 
typedef V2::value_type value2_type
 
typedef V1::size_type size_type
 
typedef V1::difference_type difference_type
 
typedef index_pair< self_typevalue_type
 
typedef value_type reference
 
typedef const value_type const_reference
 
typedef indexed_iterator< self_type, std::random_access_iterator_tag > iterator
 
typedef indexed_const_iterator< self_type, std::random_access_iterator_tag > const_iterator
 
typedef M::size_type size_type
 
typedef V1::value_type value1_type
 
typedef V2::value_type value2_type
 
typedef V3::value_type value3_type
 
typedef V1::size_type size_type
 
typedef V1::difference_type difference_type
 
typedef index_triple< self_typevalue_type
 
typedef value_type reference
 
typedef const value_type const_reference
 
typedef indexed_iterator< self_type, std::random_access_iterator_tag > iterator
 
typedef indexed_const_iterator< self_type, std::random_access_iterator_tag > const_iterator
 
typedef T value_type
 
typedef type_traits< T >::const_reference argument_type
 
typedef type_traits< T >::value_type result_type
 
typedef scalar_unary_functor< T >::argument_type argument_type
 
typedef scalar_unary_functor< T >::result_type result_type
 
typedef scalar_unary_functor< T >::argument_type argument_type
 
typedef scalar_unary_functor< T >::result_type result_type
 
typedef scalar_unary_functor< T >::value_type value_type
 
typedef scalar_unary_functor< T >::argument_type argument_type
 
typedef scalar_unary_functor< T >::result_type result_type
 
typedef T value_type
 
typedef type_traits< T >::const_reference argument_type
 
typedef type_traits< T >::real_type result_type
 
typedef scalar_real_unary_functor< T >::value_type value_type
 
typedef scalar_real_unary_functor< T >::argument_type argument_type
 
typedef scalar_real_unary_functor< T >::result_type result_type
 
typedef scalar_real_unary_functor< T >::value_type value_type
 
typedef scalar_real_unary_functor< T >::argument_type argument_type
 
typedef scalar_real_unary_functor< T >::result_type result_type
 
typedef type_traits< T1 >::const_reference argument1_type
 
typedef type_traits< T2 >::const_reference argument2_type
 
typedef promote_traits< T1, T2 >::promote_type result_type
 
typedef scalar_binary_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_binary_functor< T1, T2 >::result_type result_type
 
typedef scalar_binary_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_binary_functor< T1, T2 >::result_type result_type
 
typedef scalar_binary_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_binary_functor< T1, T2 >::result_type result_type
 
typedef scalar_binary_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_binary_functor< T1, T2 >::result_type result_type
 
typedef type_traits< typename boost::remove_reference< T1 >::type >::reference argument1_type
 
typedef type_traits< T2 >::const_reference argument2_type
 
typedef scalar_binary_assign_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_assign_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_assign< U1, U2 > other
 
typedef scalar_binary_assign_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_assign_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_plus_assign< U1, U2 > other
 
typedef scalar_binary_assign_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_assign_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_minus_assign< U1, U2 > other
 
typedef scalar_binary_assign_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_assign_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_multiplies_assign< U1, U2 > other
 
typedef scalar_binary_assign_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_assign_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_divides_assign< U1, U2 > other
 
typedef type_traits< typename boost::remove_reference< T1 >::type >::reference argument1_type
 
typedef type_traits< typename boost::remove_reference< T2 >::type >::reference argument2_type
 
typedef scalar_binary_swap_functor< T1, T2 >::argument1_type argument1_type
 
typedef scalar_binary_swap_functor< T1, T2 >::argument2_type argument2_type
 
typedef scalar_swap< U1, U2 > other
 
typedef V::value_type value_type
 
typedef V::value_type result_type
 
typedef vector_scalar_unary_functor< V >::value_type value_type
 
typedef vector_scalar_unary_functor< V >::result_type result_type
 
typedef V::value_type value_type
 
typedef type_traits< value_type >::real_type real_type
 
typedef real_type result_type
 
typedef vector_scalar_real_unary_functor< V >::value_type value_type
 
typedef vector_scalar_real_unary_functor< V >::real_type real_type
 
typedef vector_scalar_real_unary_functor< V >::result_type result_type
 
typedef vector_scalar_real_unary_functor< V >::value_type value_type
 
typedef vector_scalar_real_unary_functor< V >::real_type real_type
 
typedef vector_scalar_real_unary_functor< V >::result_type result_type
 
typedef vector_scalar_real_unary_functor< V >::value_type value_type
 
typedef vector_scalar_real_unary_functor< V >::real_type real_type
 
typedef vector_scalar_real_unary_functor< V >::result_type result_type
 
typedef V::value_type value_type
 
typedef type_traits< value_type >::real_type real_type
 
typedef V::size_type result_type
 
typedef vector_scalar_index_unary_functor< V >::value_type value_type
 
typedef vector_scalar_index_unary_functor< V >::real_type real_type
 
typedef vector_scalar_index_unary_functor< V >::result_type result_type
 
typedef TV value_type
 
typedef TV result_type
 
typedef vector_scalar_binary_functor< V1, V2, TV >::value_type value_type
 
typedef vector_scalar_binary_functor< V1, V2, TV >::result_type result_type
 
typedef M1::size_type size_type
 
typedef M1::difference_type difference_type
 
typedef TV value_type
 
typedef TV result_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::size_type size_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::difference_type difference_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::value_type value_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::result_type result_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::size_type size_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::difference_type difference_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::value_type value_type
 
typedef matrix_vector_binary_functor< M1, M2, TV >::result_type result_type
 
typedef M1::size_type size_type
 
typedef M1::difference_type difference_type
 
typedef TV value_type
 
typedef TV result_type
 
typedef matrix_matrix_binary_functor< M1, M2, TV >::size_type size_type
 
typedef matrix_matrix_binary_functor< M1, M2, TV >::difference_type difference_type
 
typedef matrix_matrix_binary_functor< M1, M2, TV >::value_type value_type
 
typedef matrix_matrix_binary_functor< M1, M2, TV >::result_type result_type
 
typedef M::value_type value_type
 
typedef type_traits< value_type >::real_type real_type
 
typedef real_type result_type
 
typedef matrix_scalar_real_unary_functor< M >::value_type value_type
 
typedef matrix_scalar_real_unary_functor< M >::real_type real_type
 
typedef matrix_scalar_real_unary_functor< M >::result_type result_type
 
typedef matrix_scalar_real_unary_functor< M >::value_type value_type
 
typedef matrix_scalar_real_unary_functor< M >::real_type real_type
 
typedef matrix_scalar_real_unary_functor< M >::result_type result_type
 
typedef matrix_scalar_real_unary_functor< M >::value_type value_type
 
typedef matrix_scalar_real_unary_functor< M >::real_type real_type
 
typedef matrix_scalar_real_unary_functor< M >::result_type result_type
 
typedef Z size_type
 
typedef D difference_type
 
typedef row_major_tag orientation_category
 
typedef basic_column_major< Z, D > transposed_layout
 
typedef Z size_type
 
typedef D difference_type
 
typedef column_major_tag orientation_category
 
typedef basic_row_major< Z, D > transposed_layout
 
typedef Z size_type
 
typedef L::size_type size_type
 
typedef Z size_type
 
typedef lower_tag triangular_type
 
typedef Z size_type
 
typedef unit_lower_tag triangular_type
 
typedef Z size_type
 
typedef strict_lower_tag triangular_type
 
typedef upper_tag triangular_type
 
typedef unit_upper_tag triangular_type
 
typedef strict_upper_tag triangular_type
 
typedef E expression_type
 
typedef E expression_type
 
typedef scalar_tag type_category
 
typedef T value_type
 
typedef const value_type & const_reference
 
typedef boost::mpl::if_< boost::is_const< T >, const_reference, value_type & >::type reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef T value_type
 
typedef const value_type & const_reference
 
typedef boost::mpl::if_< boost::is_const< T >, const_reference, value_type & >::type reference
 
typedef const scalar_reference< const self_typeconst_closure_type
 
typedef scalar_reference< self_typeclosure_type
 
typedef E expression_type
 
typedef vector_tag type_category
 
typedef C container_type
 
typedef vector_tag type_category
 
typedef E expression_type
 
typedef matrix_tag type_category
 
typedef C container_type
 
typedef matrix_tag type_category
 
typedef E::size_type size_type
 
typedef E::difference_type difference_type
 
typedef E::value_type value_type
 
typedef E::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< E >, typename E::const_reference, typename E::reference >::type reference
 
typedef E referred_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef E::storage_category storage_category
 
typedef E::const_iterator const_iterator
 
typedef boost::mpl::if_< boost::is_const< E >, typename E::const_iterator, typename E::iterator >::type iterator
 
typedef reverse_iterator_base< const_iterator > const_reverse_iterator
 
typedef reverse_iterator_base< iterator > reverse_iterator
 
typedef E::size_type size_type
 
typedef E::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef boost::mpl::if_< boost::is_same< F, scalar_identity< value_type > >, typename E::reference, value_type >::type reference
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator iterator
 
typedef E::const_iterator::iterator_category iterator_category
 
typedef vector_unary::difference_type difference_type
 
typedef vector_unary::value_type value_type
 
typedef vector_unary::const_reference reference
 
typedef vector_unary::const_pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef vector_unary< E, F > expression_type
 
typedef expression_type result_type
 
typedef promote_traits< typename E1::size_type, typename E2::size_type >::promote_type size_type
 
typedef promote_traits< typename E1::difference_type, typename E2::difference_type >::promote_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator iterator
 
typedef iterator_restrict_traits< typename E1::const_iterator::iterator_category, typename E2::const_iterator::iterator_category >::iterator_category iterator_category
 
typedef vector_binary::difference_type difference_type
 
typedef vector_binary::value_type value_type
 
typedef vector_binary::const_reference reference
 
typedef vector_binary::const_pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef vector_binary< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef const E1 & expression1_closure_type
 
typedef E2::const_closure_type expression2_closure_type
 
typedef E2::size_type size_type
 
typedef E2::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator iterator
 
typedef E2::const_iterator::iterator_category iterator_category
 
typedef vector_binary_scalar1::difference_type difference_type
 
typedef vector_binary_scalar1::value_type value_type
 
typedef vector_binary_scalar1::const_reference reference
 
typedef vector_binary_scalar1::const_pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef vector_binary_scalar1< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef E1::size_type size_type
 
typedef E1::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator iterator
 
typedef E1::const_iterator::iterator_category iterator_category
 
typedef vector_binary_scalar2::difference_type difference_type
 
typedef vector_binary_scalar2::value_type value_type
 
typedef vector_binary_scalar2::const_reference reference
 
typedef vector_binary_scalar2::const_pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef vector_binary_scalar2< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef F::result_type value_type
 
typedef E::difference_type difference_type
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef vector_scalar_unary< E, F > expression_type
 
typedef F::result_type result_type
 
typedef F::result_type value_type
 
typedef E1::difference_type difference_type
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef vector_scalar_binary< E1, E2, F > expression_type
 
typedef F::result_type result_type
 
typedef SC storage_category
 
typedef packed_tag storage_category
 
typedef sparse_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef packed_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef SC storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef A::size_type size_type
 
typedef A::difference_type difference_type
 
typedef T value_type
 
typedef type_traits< T >::const_reference const_reference
 
typedef T & reference
 
typedef T * pointer
 
typedef const T * const_pointer
 
typedef A array_type
 
typedef const vector_reference< const self_typeconst_closure_type
 
typedef vector_reference< self_typeclosure_type
 
typedef self_type vector_temporary_type
 
typedef dense_tag storage_category
 
typedef vector::difference_type difference_type
 
typedef vector::value_type value_type
 
typedef vector::const_reference reference
 
typedef const vector::pointer pointer
 
typedef vector::difference_type difference_type
 
typedef vector::value_type value_type
 
typedef vector::reference reference
 
typedef vector::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef vector_type::size_type size_type
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const vector_reference< const self_typeconst_closure_type
 
typedef vector_reference< self_typeclosure_type
 
typedef sparse_tag storage_category
 
typedef zero_vector::difference_type difference_type
 
typedef zero_vector::value_type value_type
 
typedef zero_vector::const_reference reference
 
typedef zero_vector::const_pointer pointer
 
typedef const_iterator iterator
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const vector_reference< const self_typeconst_closure_type
 
typedef vector_reference< self_typeclosure_type
 
typedef sparse_tag storage_category
 
typedef unit_vector::difference_type difference_type
 
typedef unit_vector::value_type value_type
 
typedef unit_vector::const_reference reference
 
typedef unit_vector::const_pointer pointer
 
typedef const_iterator iterator
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const vector_reference< const self_typeconst_closure_type
 
typedef vector_reference< self_typeclosure_type
 
typedef dense_tag storage_category
 
typedef scalar_vector::difference_type difference_type
 
typedef scalar_vector::value_type value_type
 
typedef scalar_vector::const_reference reference
 
typedef scalar_vector::const_pointer pointer
 
typedef const_iterator iterator
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef std::size_t size_type
 
typedef std::ptrdiff_t difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef value_type array_type[N]
 
typedef T * pointer
 
typedef const T * const_pointer
 
typedef const vector_reference< const self_typeconst_closure_type
 
typedef vector_reference< self_typeclosure_type
 
typedef self_type vector_temporary_type
 
typedef dense_tag storage_category
 
typedef c_vector::difference_type difference_type
 
typedef c_vector::value_type value_type
 
typedef c_vector::const_reference reference
 
typedef c_vector::const_pointer pointer
 
typedef c_vector::difference_type difference_type
 
typedef c_vector::value_type value_type
 
typedef c_vector::reference reference
 
typedef c_vector::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef E::size_type size_type
 
typedef E::difference_type difference_type
 
typedef E::value_type value_type
 
typedef E::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< E >, typename E::const_reference, typename E::reference >::type reference
 
typedef E referred_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef E::orientation_category orientation_category
 
typedef E::storage_category storage_category
 
typedef E::const_iterator1 const_iterator1
 
typedef boost::mpl::if_< boost::is_const< E >, typename E::const_iterator1, typename E::iterator1 >::type iterator1
 
typedef E::const_iterator2 const_iterator2
 
typedef boost::mpl::if_< boost::is_const< E >, typename E::const_iterator2, typename E::iterator2 >::type iterator2
 
typedef reverse_iterator_base1< const_iterator1 > const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1 > reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2 > const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2 > reverse_iterator2
 
typedef E1::const_closure_type expression1_closure_type
 
typedef E2::const_closure_type expression2_closure_type
 
typedef F functor_type
 
typedef promote_traits< typename E1::size_type, typename E2::size_type >::promote_type size_type
 
typedef promote_traits< typename E1::difference_type, typename E2::difference_type >::promote_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_orientation_tag orientation_category
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef iterator_restrict_traits< typename E1::const_iterator::iterator_category, typename E2::const_iterator::iterator_category >::iterator_category iterator_category
 
typedef vector_matrix_binary::difference_type difference_type
 
typedef vector_matrix_binary::value_type value_type
 
typedef vector_matrix_binary::const_reference reference
 
typedef vector_matrix_binary::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef iterator_restrict_traits< typename E1::const_iterator::iterator_category, typename E2::const_iterator::iterator_category >::iterator_category iterator_category
 
typedef vector_matrix_binary::difference_type difference_type
 
typedef vector_matrix_binary::value_type value_type
 
typedef vector_matrix_binary::const_reference reference
 
typedef vector_matrix_binary::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef vector_matrix_binary< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef E::const_closure_type expression_closure_type
 
typedef E::size_type size_type
 
typedef E::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef E::orientation_category orientation_category
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef E::const_iterator1::iterator_category iterator_category
 
typedef matrix_unary1::difference_type difference_type
 
typedef matrix_unary1::value_type value_type
 
typedef matrix_unary1::const_reference reference
 
typedef matrix_unary1::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef E::const_iterator2::iterator_category iterator_category
 
typedef matrix_unary1::difference_type difference_type
 
typedef matrix_unary1::value_type value_type
 
typedef matrix_unary1::const_reference reference
 
typedef matrix_unary1::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix_unary1< E, F > expression_type
 
typedef expression_type result_type
 
typedef boost::mpl::if_< boost::is_const< expression_type >, typename E::const_closure_type, typename E::closure_type >::type expression_closure_type
 
typedef E::size_type size_type
 
typedef E::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef boost::mpl::if_< boost::is_same< F, scalar_identity< value_type > >, typename E::reference, value_type >::type reference
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef boost::mpl::if_< boost::is_same< typename E::orientation_category, row_major_tag >, column_major_tag, typename boost::mpl::if_< boost::is_same< typename E::orientation_category, column_major_tag >, row_major_tag, typename E::orientation_category >::type >::type orientation_category
 
typedef E::storage_category storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef E::const_iterator2::iterator_category iterator_category
 
typedef matrix_unary2::difference_type difference_type
 
typedef matrix_unary2::value_type value_type
 
typedef matrix_unary2::const_reference reference
 
typedef matrix_unary2::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef E::const_iterator1::iterator_category iterator_category
 
typedef matrix_unary2::difference_type difference_type
 
typedef matrix_unary2::value_type value_type
 
typedef matrix_unary2::const_reference reference
 
typedef matrix_unary2::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix_unary2< E, F > expression_type
 
typedef expression_type result_type
 
typedef E1::const_closure_type expression1_closure_type
 
typedef E2::const_closure_type expression2_closure_type
 
typedef promote_traits< typename E1::size_type, typename E2::size_type >::promote_type size_type
 
typedef promote_traits< typename E1::difference_type, typename E2::difference_type >::promote_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_orientation_tag orientation_category
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef iterator_restrict_traits< typename E1::const_iterator1::iterator_category, typename E2::const_iterator1::iterator_category >::iterator_category iterator_category
 
typedef matrix_binary::difference_type difference_type
 
typedef matrix_binary::value_type value_type
 
typedef matrix_binary::const_reference reference
 
typedef matrix_binary::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef iterator_restrict_traits< typename E1::const_iterator2::iterator_category, typename E2::const_iterator2::iterator_category >::iterator_category iterator_category
 
typedef matrix_binary::difference_type difference_type
 
typedef matrix_binary::value_type value_type
 
typedef matrix_binary::const_reference reference
 
typedef matrix_binary::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix_binary< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef E2::size_type size_type
 
typedef E2::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef E2::orientation_category orientation_category
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef E2::const_iterator1::iterator_category iterator_category
 
typedef matrix_binary_scalar1::difference_type difference_type
 
typedef matrix_binary_scalar1::value_type value_type
 
typedef matrix_binary_scalar1::const_reference reference
 
typedef matrix_binary_scalar1::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef E2::const_iterator2::iterator_category iterator_category
 
typedef matrix_binary_scalar1::difference_type difference_type
 
typedef matrix_binary_scalar1::value_type value_type
 
typedef matrix_binary_scalar1::const_reference reference
 
typedef matrix_binary_scalar1::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix_binary_scalar1< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef E1::const_closure_type expression1_closure_type
 
typedef const E2 & expression2_closure_type
 
typedef E1::size_type size_type
 
typedef E1::difference_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef E1::orientation_category orientation_category
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef E1::const_iterator1::iterator_category iterator_category
 
typedef matrix_binary_scalar2::difference_type difference_type
 
typedef matrix_binary_scalar2::value_type value_type
 
typedef matrix_binary_scalar2::const_reference reference
 
typedef matrix_binary_scalar2::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef E1::const_iterator2::iterator_category iterator_category
 
typedef matrix_binary_scalar2::difference_type difference_type
 
typedef matrix_binary_scalar2::value_type value_type
 
typedef matrix_binary_scalar2::const_reference reference
 
typedef matrix_binary_scalar2::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix_binary_scalar2< E1, E2, F > expression_type
 
typedef expression_type result_type
 
typedef E1 expression1_type
 
typedef E2 expression2_type
 
typedef E1::const_closure_type expression1_closure_type
 
typedef E2::const_closure_type expression2_closure_type
 
typedef promote_traits< typename E1::size_type, typename E2::size_type >::promote_type size_type
 
typedef promote_traits< typename E1::difference_type, typename E2::difference_type >::promote_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator iterator
 
typedef iterator_restrict_traits< typename E1::const_iterator1::iterator_category, typename E2::const_iterator::iterator_category >::iterator_category iterator_category
 
typedef matrix_vector_binary1::difference_type difference_type
 
typedef matrix_vector_binary1::value_type value_type
 
typedef matrix_vector_binary1::const_reference reference
 
typedef matrix_vector_binary1::const_pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef unknown_storage_tag storage_category
 
typedef row_major_tag orientation_category
 
typedef promote_traits< T1, T2 >::promote_type promote_type
 
typedef matrix_vector_binary1< E1, E2, matrix_vector_prod1< E1, E2, promote_type > > expression_type
 
typedef expression_type result_type
 
typedef E1::const_closure_type expression1_closure_type
 
typedef E2::const_closure_type expression2_closure_type
 
typedef promote_traits< typename E1::size_type, typename E2::size_type >::promote_type size_type
 
typedef promote_traits< typename E1::difference_type, typename E2::difference_type >::promote_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator iterator
 
typedef iterator_restrict_traits< typename E1::const_iterator::iterator_category, typename E2::const_iterator2::iterator_category >::iterator_category iterator_category
 
typedef matrix_vector_binary2::difference_type difference_type
 
typedef matrix_vector_binary2::value_type value_type
 
typedef matrix_vector_binary2::const_reference reference
 
typedef matrix_vector_binary2::const_pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef unknown_storage_tag storage_category
 
typedef column_major_tag orientation_category
 
typedef promote_traits< T1, T2 >::promote_type promote_type
 
typedef matrix_vector_binary2< E1, E2, matrix_vector_prod2< E1, E2, promote_type > > expression_type
 
typedef expression_type result_type
 
typedef E1 expression1_type
 
typedef E2 expression2_type
 
typedef E1::const_closure_type expression1_closure_type
 
typedef E2::const_closure_type expression2_closure_type
 
typedef promote_traits< typename E1::size_type, typename E2::size_type >::promote_type size_type
 
typedef promote_traits< typename E1::difference_type, typename E2::difference_type >::promote_type difference_type
 
typedef F::result_type value_type
 
typedef value_type const_reference
 
typedef const_reference reference
 
typedef const self_type const_closure_type
 
typedef const_closure_type closure_type
 
typedef unknown_orientation_tag orientation_category
 
typedef unknown_storage_tag storage_category
 
typedef const_iterator1 iterator1
 
typedef const_iterator2 iterator2
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef iterator_restrict_traits< typename E1::const_iterator1::iterator_category, typename E2::const_iterator2::iterator_category >::iterator_category iterator_category
 
typedef matrix_matrix_binary::difference_type difference_type
 
typedef matrix_matrix_binary::value_type value_type
 
typedef matrix_matrix_binary::const_reference reference
 
typedef matrix_matrix_binary::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef iterator_restrict_traits< typename E1::const_iterator1::iterator_category, typename E2::const_iterator2::iterator_category >::iterator_category iterator_category
 
typedef matrix_matrix_binary::difference_type difference_type
 
typedef matrix_matrix_binary::value_type value_type
 
typedef matrix_matrix_binary::const_reference reference
 
typedef matrix_matrix_binary::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef unknown_storage_tag storage_category
 
typedef unknown_orientation_tag orientation_category
 
typedef promote_traits< T1, T2 >::promote_type promote_type
 
typedef matrix_matrix_binary< E1, E2, matrix_matrix_prod< E1, E2, promote_type > > expression_type
 
typedef expression_type result_type
 
typedef E expression_type
 
typedef F functor_type
 
typedef F::result_type value_type
 
typedef E::const_closure_type expression_closure_type
 
typedef matrix_scalar_unary< E, F > expression_type
 
typedef expression_type result_type
 
typedef SC storage_category
 
typedef packed_tag storage_category
 
typedef sparse_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef packed_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef SC storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef sparse_proxy_tag storage_category
 
typedef A::size_type size_type
 
typedef A::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef A array_type
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef vector< T, A > vector_temporary_type
 
typedef self_type matrix_temporary_type
 
typedef dense_tag storage_category
 
typedef L::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef matrix::value_type value_type
 
typedef matrix::difference_type difference_type
 
typedef matrix::const_reference reference
 
typedef const matrix::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef matrix::value_type value_type
 
typedef matrix::difference_type difference_type
 
typedef matrix::reference reference
 
typedef matrix::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef matrix::value_type value_type
 
typedef matrix::difference_type difference_type
 
typedef matrix::const_reference reference
 
typedef const matrix::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix::value_type value_type
 
typedef matrix::difference_type difference_type
 
typedef matrix::reference reference
 
typedef matrix::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef matrix_type::size_type size_type
 
typedef A::size_type size_type
 
typedef A::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef A array_type
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef vector< T, typename A::value_type > vector_temporary_type
 
typedef self_type matrix_temporary_type
 
typedef dense_tag storage_category
 
typedef L::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef vector_of_vector::value_type value_type
 
typedef vector_of_vector::difference_type difference_type
 
typedef vector_of_vector::const_reference reference
 
typedef const vector_of_vector::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef vector_of_vector::value_type value_type
 
typedef vector_of_vector::difference_type difference_type
 
typedef vector_of_vector::reference reference
 
typedef vector_of_vector::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef vector_of_vector::value_type value_type
 
typedef vector_of_vector::difference_type difference_type
 
typedef vector_of_vector::const_reference reference
 
typedef const vector_of_vector::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef vector_of_vector::value_type value_type
 
typedef vector_of_vector::difference_type difference_type
 
typedef vector_of_vector::reference reference
 
typedef vector_of_vector::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef sparse_tag storage_category
 
typedef unknown_orientation_tag orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef zero_matrix::value_type value_type
 
typedef zero_matrix::difference_type difference_type
 
typedef zero_matrix::const_reference reference
 
typedef zero_matrix::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef const_iterator1 iterator1
 
typedef zero_matrix::value_type value_type
 
typedef zero_matrix::difference_type difference_type
 
typedef zero_matrix::const_reference reference
 
typedef zero_matrix::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef const_iterator2 iterator2
 
typedef ALLOC::size_type size_type
 
typedef ALLOC::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef sparse_tag storage_category
 
typedef unknown_orientation_tag orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef identity_matrix::value_type value_type
 
typedef identity_matrix::difference_type difference_type
 
typedef identity_matrix::const_reference reference
 
typedef identity_matrix::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef const_iterator1 iterator1
 
typedef identity_matrix::value_type value_type
 
typedef identity_matrix::difference_type difference_type
 
typedef identity_matrix::const_reference reference
 
typedef identity_matrix::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef const_iterator2 iterator2
 
typedef std::size_t size_type
 
typedef std::ptrdiff_t difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef dense_tag storage_category
 
typedef unknown_orientation_tag orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef scalar_matrix::value_type value_type
 
typedef scalar_matrix::difference_type difference_type
 
typedef scalar_matrix::const_reference reference
 
typedef scalar_matrix::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef const_iterator1 iterator1
 
typedef scalar_matrix::value_type value_type
 
typedef scalar_matrix::difference_type difference_type
 
typedef scalar_matrix::const_reference reference
 
typedef scalar_matrix::const_pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef const_iterator2 iterator2
 
typedef std::size_t size_type
 
typedef std::ptrdiff_t difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef const T * const_pointer
 
typedef T * pointer
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef c_vector< T, N *M > vector_temporary_type
 
typedef self_type matrix_temporary_type
 
typedef dense_tag storage_category
 
typedef row_major_tag orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef c_matrix::difference_type difference_type
 
typedef c_matrix::value_type value_type
 
typedef c_matrix::const_reference reference
 
typedef c_matrix::const_pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef c_matrix::difference_type difference_type
 
typedef c_matrix::value_type value_type
 
typedef c_matrix::reference reference
 
typedef c_matrix::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef c_matrix::difference_type difference_type
 
typedef c_matrix::value_type value_type
 
typedef c_matrix::const_reference reference
 
typedef c_matrix::const_reference pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef c_matrix::difference_type difference_type
 
typedef c_matrix::value_type value_type
 
typedef c_matrix::reference reference
 
typedef c_matrix::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef M::vector_temporary_type type
 
typedef M::matrix_temporary_type type
 
typedef M matrix_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef const_subiterator_type::value_type value_type
 
typedef const_subiterator_type::difference_type difference_type
 
typedef const_subiterator_type::reference reference
 
typedef const_subiterator_type::pointer pointer
 
typedef subiterator_type::value_type value_type
 
typedef subiterator_type::difference_type difference_type
 
typedef subiterator_type::reference reference
 
typedef subiterator_type::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef M matrix_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef const_subiterator_type::value_type value_type
 
typedef const_subiterator_type::difference_type difference_type
 
typedef const_subiterator_type::reference reference
 
typedef const_subiterator_type::pointer pointer
 
typedef subiterator_type::value_type value_type
 
typedef subiterator_type::difference_type difference_type
 
typedef subiterator_type::reference reference
 
typedef subiterator_type::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef M matrix_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef matrix_vector_range::value_type value_type
 
typedef matrix_vector_range::difference_type difference_type
 
typedef matrix_vector_range::const_reference reference
 
typedef const matrix_vector_range::value_type * pointer
 
typedef matrix_vector_range::value_type value_type
 
typedef matrix_vector_range::difference_type difference_type
 
typedef matrix_vector_range::reference reference
 
typedef matrix_vector_range::value_type * pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef M matrix_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef basic_slice< size_type, difference_type > slice_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef matrix_vector_slice::value_type value_type
 
typedef matrix_vector_slice::difference_type difference_type
 
typedef matrix_vector_slice::const_reference reference
 
typedef const matrix_vector_slice::value_type * pointer
 
typedef matrix_vector_slice::value_type value_type
 
typedef matrix_vector_slice::difference_type difference_type
 
typedef matrix_vector_slice::reference reference
 
typedef matrix_vector_slice::value_type * pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef M matrix_type
 
typedef IA indirect_array_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef matrix_vector_indirect::value_type value_type
 
typedef matrix_vector_indirect::difference_type difference_type
 
typedef matrix_vector_indirect::const_reference reference
 
typedef const matrix_vector_indirect::value_type * pointer
 
typedef matrix_vector_indirect::value_type value_type
 
typedef matrix_vector_indirect::difference_type difference_type
 
typedef matrix_vector_indirect::reference reference
 
typedef matrix_vector_indirect::value_type * pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef M matrix_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef M::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef const_subiterator1_type::value_type value_type
 
typedef const_subiterator1_type::difference_type difference_type
 
typedef const_subiterator1_type::reference reference
 
typedef const_subiterator1_type::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef subiterator1_type::value_type value_type
 
typedef subiterator1_type::difference_type difference_type
 
typedef subiterator1_type::reference reference
 
typedef subiterator1_type::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef const_subiterator2_type::value_type value_type
 
typedef const_subiterator2_type::difference_type difference_type
 
typedef const_subiterator2_type::reference reference
 
typedef const_subiterator2_type::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef subiterator2_type::value_type value_type
 
typedef subiterator2_type::difference_type difference_type
 
typedef subiterator2_type::reference reference
 
typedef subiterator2_type::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef M matrix_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef basic_slice< size_type, difference_type > slice_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef M::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef M::const_iterator1::value_type value_type
 
typedef M::const_iterator1::difference_type difference_type
 
typedef M::const_reference reference
 
typedef M::const_iterator1::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef M::iterator1::value_type value_type
 
typedef M::iterator1::difference_type difference_type
 
typedef M::reference reference
 
typedef M::iterator1::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef M::const_iterator2::value_type value_type
 
typedef M::const_iterator2::difference_type difference_type
 
typedef M::const_reference reference
 
typedef M::const_iterator2::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef M::iterator2::value_type value_type
 
typedef M::iterator2::difference_type difference_type
 
typedef M::reference reference
 
typedef M::iterator2::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef M matrix_type
 
typedef IA indirect_array_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef basic_slice< size_type, difference_type > slice_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef M::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef M::const_iterator1::value_type value_type
 
typedef M::const_iterator1::difference_type difference_type
 
typedef M::const_reference reference
 
typedef M::const_iterator1::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef M::iterator1::value_type value_type
 
typedef M::iterator1::difference_type difference_type
 
typedef M::reference reference
 
typedef M::iterator1::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef M::const_iterator2::value_type value_type
 
typedef M::const_iterator2::difference_type difference_type
 
typedef M::const_reference reference
 
typedef M::const_iterator2::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef M::iterator2::value_type value_type
 
typedef M::iterator2::difference_type difference_type
 
typedef M::reference reference
 
typedef M::iterator2::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef const V const_vector_type
 
typedef V vector_type
 
typedef V::size_type size_type
 
typedef V::difference_type difference_type
 
typedef V::value_type value_type
 
typedef V::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< V >, typename V::const_reference, typename V::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< V >, typename V::const_closure_type, typename V::closure_type >::type vector_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename V::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef const_subiterator_type::difference_type difference_type
 
typedef const_subiterator_type::value_type value_type
 
typedef const_subiterator_type::reference reference
 
typedef const_subiterator_type::pointer pointer
 
typedef subiterator_type::difference_type difference_type
 
typedef subiterator_type::value_type value_type
 
typedef subiterator_type::reference reference
 
typedef subiterator_type::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef const V const_vector_type
 
typedef V vector_type
 
typedef V::size_type size_type
 
typedef V::difference_type difference_type
 
typedef V::value_type value_type
 
typedef V::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< V >, typename V::const_reference, typename V::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< V >, typename V::const_closure_type, typename V::closure_type >::type vector_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef basic_slice< size_type, difference_type > slice_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename V::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef V::const_iterator::difference_type difference_type
 
typedef V::const_iterator::value_type value_type
 
typedef V::const_reference reference
 
typedef V::const_iterator::pointer pointer
 
typedef V::iterator::difference_type difference_type
 
typedef V::iterator::value_type value_type
 
typedef V::reference reference
 
typedef V::iterator::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef const V const_vector_type
 
typedef V vector_type
 
typedef const IA const_indirect_array_type
 
typedef IA indirect_array_type
 
typedef V::size_type size_type
 
typedef V::difference_type difference_type
 
typedef V::value_type value_type
 
typedef V::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< V >, typename V::const_reference, typename V::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< V >, typename V::const_closure_type, typename V::closure_type >::type vector_closure_type
 
typedef basic_range< size_type, difference_type > range_type
 
typedef basic_slice< size_type, difference_type > slice_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename V::storage_category, dense_proxy_tag >::storage_category storage_category
 
typedef V::const_iterator::difference_type difference_type
 
typedef V::const_iterator::value_type value_type
 
typedef V::const_reference reference
 
typedef V::const_iterator::pointer pointer
 
typedef V::iterator::difference_type difference_type
 
typedef V::iterator::value_type value_type
 
typedef V::reference reference
 
typedef V::iterator::pointer pointer
 
typedef reverse_iterator_base< const_iteratorconst_reverse_iterator
 
typedef reverse_iterator_base< iteratorreverse_iterator
 
typedef A::size_type size_type
 
typedef A::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef A array_type
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef vector< T, A > vector_temporary_type
 
typedef matrix< T, L, A > matrix_temporary_type
 
typedef packed_tag storage_category
 
typedef L::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef triangular_matrix::value_type value_type
 
typedef triangular_matrix::difference_type difference_type
 
typedef triangular_matrix::const_reference reference
 
typedef const triangular_matrix::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef triangular_matrix::value_type value_type
 
typedef triangular_matrix::difference_type difference_type
 
typedef triangular_matrix::reference reference
 
typedef triangular_matrix::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef triangular_matrix::value_type value_type
 
typedef triangular_matrix::difference_type difference_type
 
typedef triangular_matrix::const_reference reference
 
typedef const triangular_matrix::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef triangular_matrix::value_type value_type
 
typedef triangular_matrix::difference_type difference_type
 
typedef triangular_matrix::reference reference
 
typedef triangular_matrix::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef const M const_matrix_type
 
typedef M matrix_type
 
typedef TRI triangular_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, packed_proxy_tag >::storage_category storage_category
 
typedef M::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef const_subiterator1_type::value_type value_type
 
typedef const_subiterator1_type::difference_type difference_type
 
typedef const_subiterator1_type::reference reference
 
typedef const_subiterator1_type::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef subiterator1_type::value_type value_type
 
typedef subiterator1_type::difference_type difference_type
 
typedef subiterator1_type::reference reference
 
typedef subiterator1_type::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef const_subiterator2_type::value_type value_type
 
typedef const_subiterator2_type::difference_type difference_type
 
typedef const_subiterator2_type::reference reference
 
typedef const_subiterator2_type::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef subiterator2_type::value_type value_type
 
typedef subiterator2_type::difference_type difference_type
 
typedef subiterator2_type::reference reference
 
typedef subiterator2_type::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef promote_traits< typename E1::value_type, typename E2::value_type >::promote_type promote_type
 
typedef vector< promote_type > result_type
 
typedef promote_traits< typename E1::value_type, typename E2::value_type >::promote_type promote_type
 
typedef matrix< promote_type > result_type
 
typedef vector< T, A > vector_type
 
typedef vector_type::size_type size_type
 
typedef A::size_type size_type
 
typedef A::difference_type difference_type
 
typedef T value_type
 
typedef const T & const_reference
 
typedef T & reference
 
typedef A array_type
 
typedef const matrix_reference< const self_typeconst_closure_type
 
typedef matrix_reference< self_typeclosure_type
 
typedef vector< T, A > vector_temporary_type
 
typedef matrix< T, L, A > matrix_temporary_type
 
typedef packed_tag storage_category
 
typedef L::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef symmetric_matrix::value_type value_type
 
typedef symmetric_matrix::difference_type difference_type
 
typedef symmetric_matrix::const_reference reference
 
typedef const symmetric_matrix::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef symmetric_matrix::value_type value_type
 
typedef symmetric_matrix::difference_type difference_type
 
typedef symmetric_matrix::reference reference
 
typedef symmetric_matrix::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef symmetric_matrix::value_type value_type
 
typedef symmetric_matrix::difference_type difference_type
 
typedef symmetric_matrix::const_reference reference
 
typedef const symmetric_matrix::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef symmetric_matrix::value_type value_type
 
typedef symmetric_matrix::difference_type difference_type
 
typedef symmetric_matrix::reference reference
 
typedef symmetric_matrix::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 
typedef const M const_matrix_type
 
typedef M matrix_type
 
typedef TRI triangular_type
 
typedef M::size_type size_type
 
typedef M::difference_type difference_type
 
typedef M::value_type value_type
 
typedef M::const_reference const_reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_reference, typename M::reference >::type reference
 
typedef boost::mpl::if_< boost::is_const< M >, typename M::const_closure_type, typename M::closure_type >::type matrix_closure_type
 
typedef const self_type const_closure_type
 
typedef self_type closure_type
 
typedef storage_restrict_traits< typename M::storage_category, packed_proxy_tag >::storage_category storage_category
 
typedef M::orientation_category orientation_category
 
typedef reverse_iterator_base1< const_iterator1const_reverse_iterator1
 
typedef reverse_iterator_base1< iterator1reverse_iterator1
 
typedef reverse_iterator_base2< const_iterator2const_reverse_iterator2
 
typedef reverse_iterator_base2< iterator2reverse_iterator2
 
typedef const_subiterator1_type::value_type value_type
 
typedef const_subiterator1_type::difference_type difference_type
 
typedef const_subiterator1_type::reference reference
 
typedef const_subiterator1_type::pointer pointer
 
typedef const_iterator2 dual_iterator_type
 
typedef const_reverse_iterator2 dual_reverse_iterator_type
 
typedef subiterator1_type::value_type value_type
 
typedef subiterator1_type::difference_type difference_type
 
typedef subiterator1_type::reference reference
 
typedef subiterator1_type::pointer pointer
 
typedef iterator2 dual_iterator_type
 
typedef reverse_iterator2 dual_reverse_iterator_type
 
typedef const_subiterator2_type::value_type value_type
 
typedef const_subiterator2_type::difference_type difference_type
 
typedef const_subiterator2_type::reference reference
 
typedef const_subiterator2_type::pointer pointer
 
typedef const_iterator1 dual_iterator_type
 
typedef const_reverse_iterator1 dual_reverse_iterator_type
 
typedef subiterator2_type::value_type value_type
 
typedef subiterator2_type::difference_type difference_type
 
typedef subiterator2_type::reference reference
 
typedef subiterator2_type::pointer pointer
 
typedef iterator1 dual_iterator_type
 
typedef reverse_iterator1 dual_reverse_iterator_type
 

Enumerations

enum  { value = 0 }
 
enum  level_type { not_serializable = 0, primitive_type = 1, object_serializable = 2, object_class_info = 3 }
 
enum  { value = 0 }
 
enum  tracking_type { track_never = 0, track_selectively = 1, track_always = 2 }
 
enum  relations {
  equal = 1, not_equal, greater, greater_equal,
  less, less_equal
}
 

Functions

 ColumnVector_Wrapper ()
 Constructor.
 
virtual ~ColumnVector_Wrapper ()
 Destructor.
 
virtual void resize (int num_rows)=0
 resize
 
virtual void assign (int newsize, double value)=0
 assign
 
virtual unsigned int rows () const =0
 Ask number of rows.
 
virtual unsigned int columns () const =0
 Ask numbers of columns (=1)
 
virtual unsigned int capacity () const =0
 capacity
 
virtual MyColumnVector vectorAdd (const MyColumnVector &v2) const =0
 join two vectors
 
virtual double operator() (unsigned int i) const =0
 element indexing
 
virtual double & operator() (unsigned int i)=0
 element indexing
 
virtual double operator[] (unsigned int i) const
 element indexing STARTING FROM 0
 
virtual double & operator[] (unsigned int i)
 element indexing STARTING FROM 0
 
virtual bool operator== (const MyColumnVector &a) const =0
 Operator ==.
 
virtual MyColumnVector & operator= (const MyColumnVector &a)=0
 operator =
 
virtual MyColumnVector & operator= (double a)=0
 Initialise all elements to a.
 
virtual MyColumnVector & operator+= (const MyColumnVector &a)=0
 Operators.
 
virtual MyColumnVector & operator-= (const MyColumnVector &a)=0
 Operators.
 
virtual MyColumnVector operator+ (const MyColumnVector &a) const =0
 Operators.
 
virtual MyColumnVector operator- (const MyColumnVector &a) const =0
 Operators.
 
virtual MyColumnVector & operator+= (double b)=0
 Operators.
 
virtual MyColumnVector & operator-= (double b)=0
 Operators.
 
virtual MyColumnVector & operator*= (double b)=0
 Operators.
 
virtual MyColumnVector & operator/= (double b)=0
 Operators.
 
virtual MyColumnVector operator+ (double b) const =0
 Operators.
 
virtual MyColumnVector operator- (double b) const =0
 Operators.
 
virtual MyColumnVector operator* (double b) const =0
 Operators.
 
virtual MyColumnVector operator/ (double b) const =0
 Operators.
 
virtual MyMatrix operator* (const MyRowVector &a) const =0
 Operators.
 
virtual MyColumnVector sub (int j_start, int j_end) const =0
 get sub matrix
 
virtual MyRowVector transpose () const =0
 get transpose
 
 RowVector_Wrapper ()
 Constructor.
 
virtual ~RowVector_Wrapper ()
 Destructor.
 
virtual void resize (int num_cols)=0
 resize
 
virtual void assign (int newsize, double value)=0
 assign
 
virtual unsigned int rows () const =0
 Ask number of rows.
 
virtual unsigned int columns () const =0
 Ask numbers of columns (=1)
 
virtual unsigned int capacity () const =0
 Ask numbers of capacity.
 
virtual MyRowVector vectorAdd (const MyRowVector &v2) const =0
 join two vectors
 
virtual double operator() (unsigned int) const =0
 element indexing
 
virtual double & operator() (unsigned int)=0
 element indexing
 
virtual bool operator== (const MyRowVector &a) const =0
 Operator ==.
 
virtual MyRowVector & operator= (const MyRowVector &a)=0
 operator =
 
virtual MyRowVector & operator= (double a)=0
 Initialise all elements to a.
 
virtual MyRowVector & operator+= (const MyRowVector &a)=0
 Operators.
 
virtual MyRowVector & operator-= (const MyRowVector &a)=0
 Operators.
 
virtual MyRowVector operator+ (const MyRowVector &a) const =0
 Operators.
 
virtual MyRowVector operator- (const MyRowVector &a) const =0
 Operators.
 
virtual MyRowVector & operator+= (double b)=0
 Operators.
 
virtual MyRowVector & operator-= (double b)=0
 Operators.
 
virtual MyRowVector & operator*= (double b)=0
 Operators.
 
virtual MyRowVector & operator/= (double b)=0
 Operators.
 
virtual MyRowVector operator+ (double b) const =0
 Operators.
 
virtual RowVector operator- (double b) const =0
 Operators.
 
virtual MyRowVector operator* (double b) const =0
 Operators.
 
virtual RowVector operator/ (double b) const =0
 Operators.
 
virtual double operator* (const MyColumnVector &a) const =0
 Operators.
 
virtual MyRowVector sub (int j_start, int j_end) const =0
 get sub matrix
 
virtual MyColumnVector transpose () const =0
 get transpose
 
 Matrix_Wrapper ()
 Constructor.
 
virtual ~Matrix_Wrapper ()
 Destructor.
 
virtual unsigned int size () const =0
 Ask Number of Rows.
 
virtual unsigned int capacity () const =0
 Ask Number of Rows.
 
virtual unsigned int rows () const =0
 Ask Number of Rows.
 
virtual unsigned int columns () const =0
 Ask Number of Columns.
 
virtual double & operator() (unsigned int, unsigned int)=0
 Operator ()
 
virtual double operator() (unsigned int, unsigned int) const =0
 Operator ()
 
virtual bool operator== (const MyMatrix &a) const =0
 Operator ==.
 
virtual MyMatrix & operator= (double a)=0
 Set all elements of the Matrix equal to a.
 
virtual MyMatrix & operator+= (double a)=0
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator-= (double a)=0
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator*= (double b)=0
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator/= (double b)=0
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator+ (double b) const =0
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator- (double b) const =0
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator* (double b) const =0
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator/ (double b) const =0
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator= (const MySymmetricMatrix &a)=0
 MATRIX - SYMMETRICMATRIX operators.
 
virtual MyMatrix & operator+= (const MyMatrix &a)=0
 MATRIX - MATRIX operator.
 
virtual MyMatrix & operator-= (const MyMatrix &a)=0
 MATRIX - MATRIX operator.
 
virtual MyMatrix operator+ (const MyMatrix &a) const =0
 MATRIX - MATRIX operator.
 
virtual MyMatrix operator- (const MyMatrix &a) const =0
 MATRIX - MATRIX operator.
 
virtual MyMatrix operator* (const MyMatrix &a) const =0
 MATRIX - MATRIX operator.
 
virtual MyColumnVector operator* (const MyColumnVector &b) const =0
 MATRIX - VECTOR operator.
 
virtual MyRowVector rowCopy (unsigned int r) const =0
 Get row from matrix.
 
virtual MyColumnVector columnCopy (unsigned int c) const =0
 Get column from matrix.
 
virtual void resize (unsigned int i, unsigned int j, bool copy=true, bool initialize=true)=0
 resize matrix
 
virtual MyMatrix pseudoinverse (double epsilon=0.01) const
 get pseudoinverse
 
virtual MyMatrix inverse () const =0
 get inverse
 
virtual MyMatrix transpose () const =0
 get transpose
 
virtual double determinant () const =0
 get determinant
 
virtual int convertToSymmetricMatrix (MySymmetricMatrix &sym)=0
 Turn matrix into Symmetric one. More...
 
virtual MyMatrix sub (int i_start, int i_end, int j_start, int j_end) const =0
 get sub matrix
 
virtual bool SVD (MyColumnVector &D, MyMatrix &U, MyMatrix &V) const
 SVD Decomposition (for pseudo-inverse properties)
 
double PYTHAG (double a, double b) const
 
double SIGN (double a, double b) const
 
 SymmetricMatrix_Wrapper ()
 Constructor.
 
virtual ~SymmetricMatrix_Wrapper ()
 Destructor.
 
virtual unsigned int size () const =0
 Ask Number of Rows.
 
virtual unsigned int capacity () const =0
 Ask Number of Rows.
 
virtual unsigned int rows () const =0
 Ask Number of Rows.
 
virtual unsigned int columns () const =0
 Ask Number of Columns.
 
virtual double & operator() (unsigned int, unsigned int)=0
 Operator ()
 
virtual double operator() (unsigned int, unsigned int) const =0
 Operator ()
 
virtual bool operator== (const MySymmetricMatrix &a) const =0
 Operator ==.
 
virtual MySymmetricMatrix & operator= (double a)=0
 Set all elements of the Matrix equal to a.
 
virtual MySymmetricMatrix & operator+= (double a)=0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix & operator-= (double a)=0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix & operator*= (double b)=0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix & operator/= (double b)=0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator+ (double b) const =0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator- (double b) const =0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator* (double b) const =0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator/ (double b) const =0
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MyMatrix & operator+= (const MyMatrix &a)=0
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix & operator-= (const MyMatrix &a)=0
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix operator+ (const MyMatrix &a) const =0
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix operator- (const MyMatrix &a) const =0
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix operator* (const MyMatrix &a) const =0
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MySymmetricMatrix & operator+= (const MySymmetricMatrix &a)=0
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MySymmetricMatrix & operator-= (const MySymmetricMatrix &a)=0
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MySymmetricMatrix operator+ (const MySymmetricMatrix &a) const =0
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MySymmetricMatrix operator- (const MySymmetricMatrix &a) const =0
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MyMatrix operator* (const MySymmetricMatrix &a) const =0
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual ColumnVector operator* (const MyColumnVector &b) const =0
 SYMMETRICMATRIX - VECTOR operator.
 
virtual void multiply (const MyColumnVector &b, MyColumnVector &result) const =0
 SYMMETRICMATRIX - VECTOR operator.
 
virtual void resize (unsigned int i, bool copy=true, bool initialize=true)=0
 resize symmetric matrix
 
virtual MySymmetricMatrix inverse () const =0
 get inverse
 
virtual MySymmetricMatrix transpose () const =0
 get transpose
 
virtual double determinant () const =0
 get determinant
 
virtual MyMatrix sub (int i_start, int i_end, int j_start, int j_end) const =0
 get sub matrix
 
virtual bool cholesky_semidefinite (MyMatrix &m) const
 Cholesky Decomposition for semidefinite matrices.
 
virtual const char * what () const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
 
template<typename _Iterator1 , typename _Iterator2 >
_GLIBCXX14_CONSTEXPR bool operator() (_Iterator1 __it1, _Iterator2 __it2) const
 
_GLIBCXX14_CONSTEXPR _Iter_less_iter __iter_less_iter ()
 
 _Iter_less_val (_Iter_less_iter)
 
template<typename _Iterator , typename _Value >
bool operator() (_Iterator __it, _Value &__val) const
 
_Iter_less_val __iter_less_val ()
 
_Iter_less_val __iter_comp_val (_Iter_less_iter)
 
 _Val_less_iter (_Iter_less_iter)
 
template<typename _Value , typename _Iterator >
bool operator() (_Value &__val, _Iterator __it) const
 
_Val_less_iter __val_less_iter ()
 
_Val_less_iter __val_comp_iter (_Iter_less_iter)
 
template<typename _Iterator1 , typename _Iterator2 >
bool operator() (_Iterator1 __it1, _Iterator2 __it2) const
 
_Iter_equal_to_iter __iter_equal_to_iter ()
 
template<typename _Iterator , typename _Value >
bool operator() (_Iterator __it, _Value &__val) const
 
_Iter_equal_to_val __iter_equal_to_val ()
 
_Iter_equal_to_val __iter_comp_val (_Iter_equal_to_iter)
 
_GLIBCXX14_CONSTEXPR _Iter_comp_iter (_Compare __comp)
 
template<typename _Iterator1 , typename _Iterator2 >
_GLIBCXX14_CONSTEXPR bool operator() (_Iterator1 __it1, _Iterator2 __it2)
 
template<typename _Compare >
_GLIBCXX14_CONSTEXPR _Iter_comp_iter< _Compare > __iter_comp_iter (_Compare __comp)
 
 _Iter_comp_val (_Compare __comp)
 
 _Iter_comp_val (const _Iter_comp_iter< _Compare > &__comp)
 
template<typename _Iterator , typename _Value >
bool operator() (_Iterator __it, _Value &__val)
 
template<typename _Compare >
_Iter_comp_val< _Compare > __iter_comp_val (_Compare __comp)
 
template<typename _Compare >
_Iter_comp_val< _Compare > __iter_comp_val (_Iter_comp_iter< _Compare > __comp)
 
 _Val_comp_iter (_Compare __comp)
 
 _Val_comp_iter (const _Iter_comp_iter< _Compare > &__comp)
 
template<typename _Value , typename _Iterator >
bool operator() (_Value &__val, _Iterator __it)
 
template<typename _Compare >
_Val_comp_iter< _Compare > __val_comp_iter (_Compare __comp)
 
template<typename _Compare >
_Val_comp_iter< _Compare > __val_comp_iter (_Iter_comp_iter< _Compare > __comp)
 
 _Iter_equals_val (_Value &__value)
 
template<typename _Iterator >
bool operator() (_Iterator __it)
 
template<typename _Value >
_Iter_equals_val< _Value > __iter_equals_val (_Value &__val)
 
 _Iter_equals_iter (_Iterator1 __it1)
 
template<typename _Iterator2 >
bool operator() (_Iterator2 __it2)
 
template<typename _Iterator >
_Iter_equals_iter< _Iterator > __iter_comp_iter (_Iter_equal_to_iter, _Iterator __it)
 
 _Iter_pred (_Predicate __pred)
 
template<typename _Iterator >
bool operator() (_Iterator __it)
 
template<typename _Predicate >
_Iter_pred< _Predicate > __pred_iter (_Predicate __pred)
 
 _Iter_comp_to_val (_Compare __comp, _Value &__value)
 
template<typename _Iterator >
bool operator() (_Iterator __it)
 
template<typename _Compare , typename _Value >
_Iter_comp_to_val< _Compare, _Value > __iter_comp_val (_Compare __comp, _Value &__val)
 
 _Iter_comp_to_iter (_Compare __comp, _Iterator1 __it1)
 
template<typename _Iterator2 >
bool operator() (_Iterator2 __it2)
 
template<typename _Compare , typename _Iterator >
_Iter_comp_to_iter< _Compare, _Iterator > __iter_comp_iter (_Iter_comp_iter< _Compare > __comp, _Iterator __it)
 
 _Iter_negate (_Predicate __pred)
 
template<typename _Iterator >
bool operator() (_Iterator __it)
 
template<typename _Predicate >
_Iter_negate< _Predicate > __negate (_Iter_pred< _Predicate > __pred)
 
virtual const char * what () const throw ()
 
new_handler set_new_handler (new_handler) throw ()
 
 Probability (double p)
 
double getValue () const
 
double & getValue ()
 
 operator double ()
 
Probability operator* (Probability p)
 
Probability operator/ (Probability p)
 
template<class U >
static U & dereference (U *p)
 
 operator const mpl::integral_c< T, val > & () const
 
BOOST_CONSTEXPR operator T () const
 
template<class T >
static T & dereference (T *p)
 
 operator const mpl::bool_< val > & () const
 
BOOST_CONSTEXPR operator bool () const
 
template<class U >
static ::boost::type_traits::yes_type is_class_tester (void(U::*)(void))
 
template<class U >
static ::boost::type_traits::no_type is_class_tester (...)
 
 BOOST_STATIC_CONSTANT (bool, value=sizeof(is_class_tester< T >(0))==sizeof(::boost::type_traits::yes_type) &&! ::boost::is_union< T >::value)
 
template<class U >
static type_traits::no_type check_sig (U(*)[1])
 
template<class U >
static type_traits::yes_type check_sig (...)
 
 BOOST_STATIC_ASSERT (sizeof(T) !=0)
 
 BOOST_STATIC_CONSTANT (std::size_t, s1=sizeof(check_sig< T >(0)))
 
 BOOST_STATIC_CONSTANT (bool, value=(s1==sizeof(type_traits::yes_type)))
 
 BOOST_STATIC_CONSTANT (bool, value=type::value)
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
template<typename T >
add_rvalue_reference< T >::type declval () BOOST_NOEXCEPT
 
 BOOST_STATIC_CONSTANT (bool, value=(::boost::detail::is_convertible_basic_impl< From, To >::value &&!::boost::is_array< To >::value &&!::boost::is_function< To >::value))
 
 BOOST_STATIC_CONSTANT (bool, value=::boost::is_class< T >::value||::boost::is_union< T >::value)
 
 int_convertible (int)
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, selector=::boost::is_arithmetic< T >::value||::boost::is_reference< T >::value||is_class_or_union< T >::value||is_array< T >::value)
 
 BOOST_STATIC_CONSTANT (bool, value=helper::value)
 
template<typename T >
static type_traits::yes_type check_sig (D const volatile *, T)
 
static type_traits::no_type check_sig (B const volatile *, int)
 
 BOOST_STATIC_ASSERT (sizeof(B) !=0)
 
 BOOST_STATIC_ASSERT (sizeof(D) !=0)
 
 operator B const volatile * () const
 
 operator D const volatile * ()
 
 BOOST_STATIC_CONSTANT (bool, value=sizeof(bd_helper< B, D >::check_sig(Host(), 0))==sizeof(type_traits::yes_type))
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, value=bound_type::value)
 
 BOOST_STATIC_CONSTANT (int, value=0)
 
 BOOST_STATIC_CONSTANT (bool, value=C_)
 
BOOST_CONSTEXPR operator bool () const
 
 BOOST_STATIC_CONSTANT (AUX_WRAPPER_VALUE_TYPE, value=N)
 
typedef AUX_WRAPPER_INST (BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE,(value+1))) next
 
typedef AUX_WRAPPER_INST (BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE,(value - 1))) prior
 
BOOST_CONSTEXPR operator AUX_WRAPPER_VALUE_TYPE () const
 
 BOOST_STATIC_CONSTANT (bool, value=C)
 
 operator bool () const
 
 BOOST_STATIC_CONSTANT (int, value=type::value)
 
template<class T , int L>
bool operator>= (implementation_level< T > t, enum level_type l)
 
 BOOST_STATIC_ASSERT (Version==0||Level >=object_class_info)
 
 BOOST_STATIC_ASSERT (Tracking==track_never||Level >=object_serializable)
 
 BOOST_STATIC_CONSTANT (int, value=type::value)
 
template<class T , enum tracking_type L>
bool operator>= (tracking_level< T > t, enum tracking_type l)
 
template<class Archive , class T >
void serialize_adl (Archive &, T &, const unsigned int)
 
template<class Archive , class T >
static void member_save (Archive &ar, T &t, const unsigned int file_version)
 
template<class Archive , class T >
static void member_load (Archive &ar, T &t, const unsigned int file_version)
 
template<class Archive , class T >
static void serialize (Archive &ar, T &t, const unsigned int file_version)
 
template<class T >
static void destroy (const T *t)
 
template<class T >
static void construct (T *t)
 
template<class T , class U >
static T & cast_reference (U &u)
 
template<class T , class U >
static T * cast_pointer (U *u)
 
static void invoke (Archive &ar, const T &t, const unsigned int file_version)
 
static void invoke (Archive &ar, T &t, const unsigned int file_version)
 
template<class Archive , class T >
void split_member (Archive &ar, T &t, const unsigned int file_version)
 
virtual void unique_name_to_boost5487629 (unique *)
 
 BOOST_STATIC_CONSTANT (bool, value=(sizeof(d2)==sizeof(d1)))
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, value=imp_type::value)
 
template<class Derived , class Base >
BOOST_DLLEXPORT const void_cast_detail::void_caster & void_cast_register (const Derived *dnull=NULL, const Base *bnull=NULL) BOOST_USED
 
 BOOST_STATIC_ASSERT (is_const< type >::value==is_const< D >::value)
 
static void const * invoke ()
 
static void const * invoke ()
 
static void const * invoke ()
 
template<class Base , class Derived >
detail::base_cast< Base, Derived >::type & base_object (Derived &d)
 
BOOST_FORCEINLINE addressof_ref (T &o) BOOST_NOEXCEPT
 
BOOST_FORCEINLINE operator T & () const BOOST_NOEXCEPT
 
static BOOST_FORCEINLINE T * get (T &o, long) BOOST_NOEXCEPT
 
static BOOST_FORCEINLINE T * get (T *p, int) BOOST_NOEXCEPT
 
static BOOST_FORCEINLINE type * get (type &o, int) BOOST_NOEXCEPT
 
static BOOST_FORCEINLINE type * get (type &o, int) BOOST_NOEXCEPT
 
static BOOST_FORCEINLINE type * get (type &o, int) BOOST_NOEXCEPT
 
static BOOST_FORCEINLINE type * get (type &o, int) BOOST_NOEXCEPT
 
template<class T >
addressof_declval () BOOST_NOEXCEPT
 
template<class T >
BOOST_FORCEINLINE addressof_if<!addressof_is_constexpr< T >::value, T >::type addressof (T &o) BOOST_NOEXCEPT
 
template<class T >
constexpr BOOST_FORCEINLINE T * addressof (T &o) BOOST_NOEXCEPT
 
template<class T >
const T * addressof (const T &&)=delete
 
 nvp (const nvp &rhs)
 
 nvp (const char *name_, T &t)
 
const char * name () const
 
T & value () const
 
const T & const_value () const
 
template<class Archive >
void save (Archive &ar, const unsigned int) const
 
template<class Archive >
void load (Archive &ar, const unsigned int)
 
template<class T >
const nvp< T > make_nvp (const char *name, T &t)
 
 BOOST_STATIC_CONSTANT (int, value=implementation_level::type::value)
 
 BOOST_STATIC_CONSTANT (int, value=tracking_level::type::value)
 
operator-> () const
 
operator[] (I n) const
 
T & operator* ()
 
T & operator++ ()
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
 BOOST_STATIC_CONSTANT (bool, value=true)
 
template<typename T , typename U , typename = decltype(boost::declval<T>() = boost::declval<U>())>
static boost::type_traits::yes_type test (int)
 
template<typename , typename >
static boost::type_traits::no_type test (...)
 
template<typename _Tp , typename = decltype(_Tp())>
static boost::type_traits::yes_type test (int)
 
template<typename >
static boost::type_traits::no_type test (...)
 
template<typename T , typename = decltype(boost::declval<T&>().~T())>
static boost::type_traits::yes_type test (int)
 
template<typename >
static boost::type_traits::no_type test (...)
 
template<typename T , typename ... TheArgs, typename = decltype(T(boost::declval<TheArgs>()...))>
static boost::type_traits::yes_type test (int)
 
template<typename , typename... >
static boost::type_traits::no_type test (...)
 
template<typename T , typename Arg , typename = decltype(::new T(boost::declval<Arg>()))>
static boost::type_traits::yes_type test1 (int)
 
template<typename , typename >
static boost::type_traits::no_type test1 (...)
 
template<typename T >
static boost::type_traits::yes_type ref_test (T)
 
template<typename T >
static boost::type_traits::no_type ref_test (...)
 
template<class Archive , class T >
void serialize (Archive &ar, T &t, const unsigned int file_version)
 
template<class Archive , class T >
void save_construct_data (Archive &, const T *, const unsigned int)
 
template<class Archive , class T >
void load_construct_data (Archive &, T *t, const unsigned int)
 
template<class Archive , class T >
void save_construct_data_adl (Archive &ar, const T *t, const unsigned int file_version)
 
template<class Archive , class T >
void load_construct_data_adl (Archive &ar, T *t, const unsigned int file_version)
 
static void invoke (Archive &ar, const T &t, const unsigned int file_version)
 
static void invoke (Archive &ar, T &t, const unsigned int file_version)
 
template<class Archive , class T >
void split_free (Archive &ar, T &t, const unsigned int file_version)
 
 collection_size_type (const std::size_t &t_)
 
 collection_size_type (const collection_size_type &t_)
 
collection_size_typeoperator= (const collection_size_type &rhs)
 
collection_size_typeoperator= (const unsigned int &rhs)
 
 operator base_type () const
 
 operator base_type & ()
 
bool operator== (const collection_size_type &rhs) const
 
bool operator< (const collection_size_type &rhs) const
 
typedef AUX778076_ASSERT_ARG (assert) type
 
static int failed (assert< false >)
 
static int failed (void *)
 
 BOOST_MPL_AUX_ASSERT_CONSTANT (bool, p=!p_type::value)
 
 array_wrapper (const array_wrapper &rhs)
 
 array_wrapper (T *t, std::size_t s)
 
template<class Archive >
void serialize_optimized (Archive &ar, const unsigned int, mpl::false_) const
 
template<class Archive >
void serialize_optimized (Archive &ar, const unsigned int version, mpl::true_)
 
template<class Archive >
void save (Archive &ar, const unsigned int version) const
 
template<class Archive >
void load (Archive &ar, const unsigned int version)
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 
T * address () const
 
std::size_t count () const
 
template<class T , class S >
const array_wrapper< T > make_array (T *t, S s)
 
template<class Archive , class T , std::size_t N>
void serialize (Archive &ar, std::array< T, N > &a, const unsigned int)
 
 noncopyable (const noncopyable &)=delete
 
noncopyableoperator= (const noncopyable &)=delete
 
template<class T >
void ignore_unused_variable_warning (const T &)
 
BOOST_UBLAS_INLINE noalias_proxy (C &lval)
 
BOOST_UBLAS_INLINE noalias_proxy (const noalias_proxy &p)
 
template<class E >
BOOST_UBLAS_INLINE closure_type & operator= (const E &e)
 
template<class E >
BOOST_UBLAS_INLINE closure_type & operator+= (const E &e)
 
template<class E >
BOOST_UBLAS_INLINE closure_type & operator-= (const E &e)
 
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 E >
static BOOST_UBLAS_INLINE E::size_type size (const vector_expression< E > &e)
 
template<class E >
static BOOST_UBLAS_INLINE E::size_type size (const matrix_expression< E > &e)
 
template<class V >
static BOOST_UBLAS_INLINE V::size_type index (const typename V::iterator &i)
 
template<class M >
static BOOST_UBLAS_INLINE M::size_type index (const typename M::iterator1 &i)
 
template<class M >
static BOOST_UBLAS_INLINE M::size_type index (const typename M::iterator2 &i)
 
template<class E >
static BOOST_UBLAS_INLINE E::size_type size (const vector_expression< E > &)
 
template<class E >
static BOOST_UBLAS_INLINE E::size_type size (const matrix_expression< E > &e)
 
template<class V >
static BOOST_UBLAS_INLINE V::size_type index (const typename V::iterator &)
 
template<class M >
static BOOST_UBLAS_INLINE M::size_type index (const typename M::iterator1 &i)
 
template<class M >
static BOOST_UBLAS_INLINE M::size_type index (const typename M::iterator2 &i)
 
template<unsigned dimension, class E >
BOOST_UBLAS_INLINE E::size_type size (const E &e)
 
template<unsigned dimension, class I >
BOOST_UBLAS_INLINE I::container_type::size_type index (const I &i)
 
template<class V >
V::size_type num_elements (const V &v)
 
template<class M >
M::size_type num_rows (const M &m)
 
template<class M >
M::size_type num_columns (const M &m)
 
template<class MV >
MV::size_type num_non_zeros (const MV &mv)
 
 divide_by_zero (const char *s="divide by zero")
 
void raise ()
 
 internal_logic (const char *s="internal logic")
 
void raise ()
 
 external_logic (const char *s="external logic")
 
void raise ()
 
 bad_argument (const char *s="bad argument")
 
void raise ()
 
 bad_size (const char *s="bad size")
 
void raise ()
 
 bad_index (const char *s="bad index")
 
void raise ()
 
 singular (const char *s="singular")
 
void raise ()
 
 non_real (const char *s="exception: non real")
 
void raise ()
 
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)
 
BOOST_UBLAS_INLINE container_const_reference (const container_type &c)
 
BOOST_UBLAS_INLINE const container_type & operator() () const
 
BOOST_UBLAS_INLINE container_const_referenceassign (const container_type *c)
 
BOOST_UBLAS_INLINE bool same_closure (const container_const_reference &cr) const
 
BOOST_UBLAS_INLINE container_reference (container_type &c)
 
BOOST_UBLAS_INLINE container_type & operator() () const
 
BOOST_UBLAS_INLINE container_referenceassign (container_type *c)
 
BOOST_UBLAS_INLINE bool same_closure (const container_reference &cr) const
 
BOOST_UBLAS_INLINE derived_iterator_type operator++ (int)
 
BOOST_UBLAS_INLINE bool operator!= (const derived_iterator_type &it) const
 
BOOST_UBLAS_INLINE derived_iterator_type operator++ (int)
 
BOOST_UBLAS_INLINE derived_iterator_type operator-- (int)
 
BOOST_UBLAS_INLINE bool operator!= (const derived_iterator_type &it) const
 
BOOST_UBLAS_INLINE derived_iterator_type operator++ (int)
 
BOOST_UBLAS_INLINE derived_iterator_type operator-- (int)
 
BOOST_UBLAS_INLINE derived_iterator_type operator+ (derived_difference_type n) const
 
BOOST_UBLAS_INLINE derived_iterator_type operator- (derived_difference_type n) const
 
BOOST_UBLAS_INLINE bool operator!= (const derived_iterator_type &it) const
 
BOOST_UBLAS_INLINE bool operator<= (const derived_iterator_type &it) const
 
BOOST_UBLAS_INLINE bool operator>= (const derived_iterator_type &it) const
 
BOOST_UBLAS_INLINE bool operator> (const derived_iterator_type &it) const
 
BOOST_UBLAS_INLINE reverse_iterator_base (const iterator_type &it)
 
BOOST_UBLAS_INLINE reverse_iterator_baseoperator++ ()
 
BOOST_UBLAS_INLINE reverse_iterator_base operator++ (int)
 
BOOST_UBLAS_INLINE reverse_iterator_baseoperator-- ()
 
BOOST_UBLAS_INLINE reverse_iterator_base operator-- (int)
 
BOOST_UBLAS_INLINE reverse_iterator_baseoperator+= (difference_type n)
 
BOOST_UBLAS_INLINE reverse_iterator_baseoperator-= (difference_type n)
 
BOOST_UBLAS_INLINE const container_type & operator() () const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE reverse_iterator_base1 (const iterator_type &it)
 
BOOST_UBLAS_INLINE reverse_iterator_base1operator++ ()
 
BOOST_UBLAS_INLINE reverse_iterator_base1 operator++ (int)
 
BOOST_UBLAS_INLINE reverse_iterator_base1operator-- ()
 
BOOST_UBLAS_INLINE reverse_iterator_base1 operator-- (int)
 
BOOST_UBLAS_INLINE reverse_iterator_base1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE reverse_iterator_base1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE const container_type & operator() () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE dual_iterator_type begin () const
 
BOOST_UBLAS_INLINE dual_iterator_type end () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rbegin () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rend () const
 
BOOST_UBLAS_INLINE reverse_iterator_base2 (const iterator_type &it)
 
BOOST_UBLAS_INLINE reverse_iterator_base2operator++ ()
 
BOOST_UBLAS_INLINE reverse_iterator_base2 operator++ (int)
 
BOOST_UBLAS_INLINE reverse_iterator_base2operator-- ()
 
BOOST_UBLAS_INLINE reverse_iterator_base2 operator-- (int)
 
BOOST_UBLAS_INLINE reverse_iterator_base2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE reverse_iterator_base2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE const container_type & operator() () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE dual_iterator_type begin () const
 
BOOST_UBLAS_INLINE dual_iterator_type end () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rbegin () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rend () const
 
BOOST_UBLAS_INLINE indexed_iterator (container_type &c, size_type it)
 
BOOST_UBLAS_INLINE indexed_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE indexed_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE indexed_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE indexed_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const indexed_iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE indexed_iteratoroperator= (const indexed_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const indexed_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const indexed_iterator &it) const
 
BOOST_UBLAS_INLINE indexed_const_iterator (const container_type &c, size_type it)
 
BOOST_UBLAS_INLINE indexed_const_iterator (const iterator_type &it)
 
BOOST_UBLAS_INLINE indexed_const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE indexed_const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE indexed_const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE indexed_const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const indexed_const_iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE indexed_const_iteratoroperator= (const indexed_const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const indexed_const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const indexed_const_iterator &it) const
 
BOOST_UBLAS_INLINE indexed_iterator1 (container_type &c, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE indexed_iterator1operator++ ()
 
BOOST_UBLAS_INLINE indexed_iterator1operator-- ()
 
BOOST_UBLAS_INLINE indexed_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE indexed_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const indexed_iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE dual_iterator_type begin () const
 
BOOST_UBLAS_INLINE dual_iterator_type end () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rbegin () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rend () const
 
BOOST_UBLAS_INLINE indexed_iterator1operator= (const indexed_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const indexed_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const indexed_iterator1 &it) const
 
BOOST_UBLAS_INLINE indexed_const_iterator1 (const container_type &c, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE indexed_const_iterator1 (const iterator_type &it)
 
BOOST_UBLAS_INLINE indexed_const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE indexed_const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE indexed_const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE indexed_const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const indexed_const_iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE dual_iterator_type begin () const
 
BOOST_UBLAS_INLINE dual_iterator_type end () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rbegin () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rend () const
 
BOOST_UBLAS_INLINE indexed_const_iterator1operator= (const indexed_const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const indexed_const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const indexed_const_iterator1 &it) const
 
BOOST_UBLAS_INLINE indexed_iterator2 (container_type &c, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE indexed_iterator2operator++ ()
 
BOOST_UBLAS_INLINE indexed_iterator2operator-- ()
 
BOOST_UBLAS_INLINE indexed_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE indexed_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const indexed_iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE dual_iterator_type begin () const
 
BOOST_UBLAS_INLINE dual_iterator_type end () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rbegin () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rend () const
 
BOOST_UBLAS_INLINE indexed_iterator2operator= (const indexed_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const indexed_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const indexed_iterator2 &it) const
 
BOOST_UBLAS_INLINE indexed_const_iterator2 (const container_type &c, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE indexed_const_iterator2 (const iterator_type &it)
 
BOOST_UBLAS_INLINE indexed_const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE indexed_const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE indexed_const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE indexed_const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const indexed_const_iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE dual_iterator_type begin () const
 
BOOST_UBLAS_INLINE dual_iterator_type end () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rbegin () const
 
BOOST_UBLAS_INLINE dual_reverse_iterator_type rend () const
 
BOOST_UBLAS_INLINE indexed_const_iterator2operator= (const indexed_const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const indexed_const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const indexed_const_iterator2 &it) const
 
template<typename X , typename Y >
cant_deduce_type test (...)
 
template<typename X , typename Y >
bool_value_type test (bool const &)
 
template<typename X , typename Y >
float_value_type test (float const &)
 
template<typename X , typename Y >
double_value_type test (double const &)
 
template<typename X , typename Y >
long_double_value_type test (long double const &)
 
template<typename X , typename Y >
char_value_type test (char const &)
 
template<typename X , typename Y >
schar_value_type test (signed char const &)
 
template<typename X , typename Y >
uchar_value_type test (unsigned char const &)
 
template<typename X , typename Y >
short_value_type test (short const &)
 
template<typename X , typename Y >
ushort_value_type test (unsigned short const &)
 
template<typename X , typename Y >
int_value_type test (int const &)
 
template<typename X , typename Y >
uint_value_type test (unsigned int const &)
 
template<typename X , typename Y >
long_value_type test (long const &)
 
template<typename X , typename Y >
ulong_value_type test (unsigned long const &)
 
template<typename X , typename Y >
disable_if< is_basic< X >, x_value_type >::type test (X const &)
 
template<typename X , typename Y >
disable_if< mpl::or_< is_basic< Y >, is_same< Y, asymmetric >, is_same< const X, const Y > >, y_value_type >::type test (Y const &)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=A< S ? A :S)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::alignment_logic< sizeof(::boost::detail::alignment_of_hack< T >) - sizeof(T), sizeof(T) >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, alignment_of_max_align=::boost::alignment_of< boost::detail::max_align >::value)
 
void * address () const
 
void * address () const
 
void * address () const
 
 BOOST_STATIC_CONSTANT (std::size_t, size=size_)
 
 BOOST_STATIC_CONSTANT (std::size_t, alignment=(alignment_==std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align :alignment_))
 
void * address ()
 
const void * address () const
 
template<template< class... > class G, class = G<T...>>
static boost::true_type check_s (int)
 
template<template< class... > class>
static boost::false_type check_s (...)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=0)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=R)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=R)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=R)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=R)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::extent_imp< T, N-1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=0)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=0)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=0)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=0)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=0)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=1)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=2)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=3)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=4)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=5)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=6)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=7)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=8)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=9)
 
 BOOST_STATIC_CONSTANT (unsigned, arity=10)
 
 BOOST_STATIC_CONSTANT (bool, value=((::boost::detail::is_base_and_derived_impl< ncvB, ncvD >::value)||(::boost::is_same< ncvB, ncvD >::value &&::boost::is_class< ncvB >::value)))
 
namespace BOOST_JOIN (BOOST_TT_TRAIT_NAME, _impl)
 
template<class U >
static type_traits::yes_type check_sig1 (U *, test< void *(*)(std::size_t), &U::operator new > *=NULL)
 
template<class U >
static type_traits::no_type check_sig1 (...)
 
template<class U >
static type_traits::yes_type check_sig2 (U *, test< void *(*)(std::size_t, const std::nothrow_t &), &U::operator new > *=NULL)
 
template<class U >
static type_traits::no_type check_sig2 (...)
 
template<class U >
static type_traits::yes_type check_sig3 (U *, test< void *(*)(std::size_t, void *), &U::operator new > *=NULL)
 
template<class U >
static type_traits::no_type check_sig3 (...)
 
template<class U >
static type_traits::yes_type check_sig4 (U *, test< void *(*)(std::size_t), &U::operator new[] > *=NULL)
 
template<class U >
static type_traits::no_type check_sig4 (...)
 
template<class U >
static type_traits::yes_type check_sig5 (U *, test< void *(*)(std::size_t, const std::nothrow_t &), &U::operator new[] > *=NULL)
 
template<class U >
static type_traits::no_type check_sig5 (...)
 
template<class U >
static type_traits::yes_type check_sig6 (U *, test< void *(*)(std::size_t, void *), &U::operator new[] > *=NULL)
 
template<class U >
static type_traits::no_type check_sig6 (...)
 
 BOOST_STATIC_CONSTANT (unsigned, s1=sizeof(check_sig1< T >(0)))
 
 BOOST_STATIC_CONSTANT (unsigned, s2=sizeof(check_sig2< T >(0)))
 
 BOOST_STATIC_CONSTANT (unsigned, s3=sizeof(check_sig3< T >(0)))
 
 BOOST_STATIC_CONSTANT (unsigned, s4=sizeof(check_sig4< T >(0)))
 
 BOOST_STATIC_CONSTANT (unsigned, s5=sizeof(check_sig5< T >(0)))
 
 BOOST_STATIC_CONSTANT (unsigned, s6=sizeof(check_sig6< T >(0)))
 
 BOOST_STATIC_CONSTANT (bool, value=(s1==sizeof(type_traits::yes_type))||(s2==sizeof(type_traits::yes_type))||(s3==sizeof(type_traits::yes_type))||(s4==sizeof(type_traits::yes_type))||(s5==sizeof(type_traits::yes_type))||(s6==sizeof(type_traits::yes_type)))
 
template<class >
static no_type test (...)
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, value=(boost::detail::is_copy_assignable_impl2< boost::is_base_and_derived< boost::noncopyable, T >::value, T >::value))
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 BOOST_STATIC_CONSTANT (bool, value=(sizeof(empty_helper_t1< T >)==sizeof(empty_helper_t2)))
 
 BOOST_STATIC_CONSTANT (bool, value=(::boost::detail::empty_helper< cvt,::boost::is_class< T >::value >::value||BOOST_INTERNAL_IS_EMPTY(cvt)))
 
 BOOST_STATIC_CONSTANT (bool, value=(!(::boost::detail::is_signed_values< T >::minus_one > boost::detail::is_signed_values< T >::zero)))
 
 BOOST_STATIC_CONSTANT (bool, value=type::value)
 
 BOOST_STATIC_CONSTANT (bool, value=(::boost::detail::is_unsigned_values< T >::minus_one > ::boost::detail::is_unsigned_values< T >::zero))
 
 BOOST_STATIC_CONSTANT (bool, value=type::value)
 
 BOOST_STATIC_CONSTANT (bool, value=false)
 
 boost_type_traits_internal_struct_X (const boost_type_traits_internal_struct_X &)
 
boost_type_traits_internal_struct_X & operator= (const boost_type_traits_internal_struct_X &)
 
 boost_type_traits_internal_struct_Y (const boost_type_traits_internal_struct_Y &)
 
boost_type_traits_internal_struct_Y & operator= (const boost_type_traits_internal_struct_Y &)
 
 BOOST_STATIC_CONSTANT (bool, value=(sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y)))
 
 BOOST_STATIC_CONSTANT (bool, value=imp::value)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=N)
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (std::size_t, value=(::boost::detail::rank_imp< T, N+1 >::value))
 
 BOOST_STATIC_CONSTANT (int, value=sizeof(promoted_index_tester(+testee)))
 
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)
 
static BOOST_UBLAS_INLINE real_type real (const_reference t)
 
static BOOST_UBLAS_INLINE real_type imag (const_reference)
 
static BOOST_UBLAS_INLINE value_type conj (const_reference t)
 
static BOOST_UBLAS_INLINE real_type type_abs (const_reference t)
 
static BOOST_UBLAS_INLINE value_type type_sqrt (const_reference t)
 
static BOOST_UBLAS_INLINE real_type norm_1 (const_reference t)
 
static BOOST_UBLAS_INLINE real_type norm_2 (const_reference t)
 
static BOOST_UBLAS_INLINE real_type norm_inf (const_reference t)
 
static BOOST_UBLAS_INLINE bool equals (const_reference t1, const_reference t2)
 
static BOOST_UBLAS_INLINE real_type real (const_reference t)
 
static BOOST_UBLAS_INLINE real_type imag (const_reference t)
 
static BOOST_UBLAS_INLINE value_type conj (const_reference t)
 
static BOOST_UBLAS_INLINE real_type type_abs (const_reference t)
 
static BOOST_UBLAS_INLINE value_type type_sqrt (const_reference t)
 
static BOOST_UBLAS_INLINE real_type norm_1 (const_reference t)
 
static BOOST_UBLAS_INLINE real_type norm_2 (const_reference t)
 
static BOOST_UBLAS_INLINE real_type norm_inf (const_reference t)
 
static BOOST_UBLAS_INLINE bool equals (const_reference t1, const_reference t2)
 
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)
 
static const_iterator begin (const VECTOR &v)
 iterator pointing to the first element
 
static const_iterator end (const VECTOR &v)
 iterator pointing behind the last element
 
static iterator begin (VECTOR &v)
 iterator pointing to the first element
 
static iterator end (VECTOR &v)
 iterator pointing behind the last element
 
BOOST_UBLAS_INLINE unbounded_array (const ALLOC &a=ALLOC())
 
BOOST_UBLAS_INLINE unbounded_array (size_type size, const ALLOC &a=ALLOC())
 
BOOST_UBLAS_INLINE unbounded_array (size_type size, const value_type &init, const ALLOC &a=ALLOC())
 
BOOST_UBLAS_INLINE unbounded_array (const unbounded_array &c)
 
BOOST_UBLAS_INLINE void resize (size_type size)
 
BOOST_UBLAS_INLINE void resize (size_type size, value_type init)
 
BOOST_UBLAS_INLINE size_type max_size () const
 
BOOST_UBLAS_INLINE bool empty () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE unbounded_arrayoperator= (const unbounded_array &a)
 
BOOST_UBLAS_INLINE unbounded_arrayassign_temporary (unbounded_array &a)
 
BOOST_UBLAS_INLINE void swap (unbounded_array &a)
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
allocator_type get_allocator ()
 
BOOST_UBLAS_INLINE bounded_array (size_type size)
 
BOOST_UBLAS_INLINE bounded_array (size_type size, const value_type &init)
 
BOOST_UBLAS_INLINE bounded_array (const bounded_array &c)
 
BOOST_UBLAS_INLINE void resize (size_type size)
 
BOOST_UBLAS_INLINE void resize (size_type size, value_type init)
 
BOOST_UBLAS_INLINE size_type max_size () const
 
BOOST_UBLAS_INLINE bool empty () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE bounded_arrayoperator= (const bounded_array &a)
 
BOOST_UBLAS_INLINE bounded_arrayassign_temporary (bounded_array &a)
 
BOOST_UBLAS_INLINE void swap (bounded_array &a)
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
BOOST_UBLAS_INLINE array_adaptor (size_type size)
 
BOOST_UBLAS_INLINE array_adaptor (size_type size, const value_type &init)
 
BOOST_UBLAS_INLINE array_adaptor (size_type size, pointer data)
 
template<size_t N>
BOOST_UBLAS_INLINE array_adaptor (T(&data)[N])
 
BOOST_UBLAS_INLINE array_adaptor (const array_adaptor &a)
 
BOOST_UBLAS_INLINE void resize (size_type size)
 
BOOST_UBLAS_INLINE void resize (size_type size, value_type init)
 
BOOST_UBLAS_INLINE void resize (size_type size, pointer data)
 
BOOST_UBLAS_INLINE void resize (size_type size, pointer data, value_type init)
 
template<size_t N>
BOOST_UBLAS_INLINE void resize (T(&data)[N])
 
template<size_t N>
BOOST_UBLAS_INLINE void resize (T(&data)[N], value_type init)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE array_adaptoroperator= (const array_adaptor &a)
 
BOOST_UBLAS_INLINE array_adaptorassign_temporary (array_adaptor &a)
 
BOOST_UBLAS_INLINE void swap (array_adaptor &a)
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
BOOST_UBLAS_INLINE basic_range (size_type start, size_type stop)
 
BOOST_UBLAS_INLINE size_type start () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE size_type max_size () const
 
BOOST_UBLAS_INLINE bool empty () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE basic_range compose (const basic_range &r) const
 
BOOST_UBLAS_INLINE bool operator== (const basic_range &r) const
 
BOOST_UBLAS_INLINE bool operator!= (const basic_range &r) const
 
BOOST_UBLAS_INLINE const_iterator (const basic_range &r, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE basic_range preprocess (size_type size) const
 
static BOOST_UBLAS_INLINE const basic_rangeall ()
 
BOOST_UBLAS_INLINE basic_slice (size_type start, difference_type stride, size_type size)
 
BOOST_UBLAS_INLINE size_type start () const
 
BOOST_UBLAS_INLINE difference_type stride () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE size_type max_size () const
 
BOOST_UBLAS_INLINE bool empty () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE basic_slice compose (const basic_range< size_type, difference_type > &r) const
 
BOOST_UBLAS_INLINE basic_slice compose (const basic_slice &s) const
 
BOOST_UBLAS_INLINE bool operator== (const basic_slice &s) const
 
BOOST_UBLAS_INLINE bool operator!= (const basic_slice &s) const
 
BOOST_UBLAS_INLINE const_iterator (const basic_slice &s, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE basic_slice preprocess (size_type size) const
 
static BOOST_UBLAS_INLINE const basic_sliceall ()
 
BOOST_UBLAS_INLINE indirect_array (size_type size)
 
BOOST_UBLAS_INLINE indirect_array (size_type size, const array_type &data)
 
BOOST_UBLAS_INLINE indirect_array (pointer start, pointer stop)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_array_type data () const
 
BOOST_UBLAS_INLINE array_type data ()
 
BOOST_UBLAS_INLINE size_type max_size () const
 
BOOST_UBLAS_INLINE bool empty () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE indirect_array compose (const basic_range< size_type, difference_type > &r) const
 
BOOST_UBLAS_INLINE indirect_array compose (const basic_slice< size_type, difference_type > &s) const
 
BOOST_UBLAS_INLINE indirect_array compose (const indirect_array &ia) const
 
template<class OA >
BOOST_UBLAS_INLINE bool operator== (const indirect_array< OA > &ia) const
 
template<class OA >
BOOST_UBLAS_INLINE bool operator!= (const indirect_array< OA > &ia) const
 
BOOST_UBLAS_INLINE const_iterator (const indirect_array &ia, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE indirect_array preprocess (size_type size) const
 
static BOOST_UBLAS_INLINE const indirect_arrayall ()
 
BOOST_UBLAS_INLINE index_pair (V &v, size_type i)
 
BOOST_UBLAS_INLINE index_pair (const self_type &rhs)
 
BOOST_UBLAS_INLINE self_typeoperator= (const self_type &rhs)
 
BOOST_UBLAS_INLINE void swap (self_type &rhs)
 
BOOST_UBLAS_INLINE bool equal (const self_type &rhs) const
 
BOOST_UBLAS_INLINE bool less (const self_type &rhs) const
 
BOOST_UBLAS_INLINE index_pair_array (size_type size, V1 &data1, V2 &data2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE bool equal (size_type i1, size_type i2) const
 
BOOST_UBLAS_INLINE bool less (size_type i1, size_type i2) const
 
BOOST_UBLAS_INLINE index_triple (M &m, size_type i)
 
BOOST_UBLAS_INLINE index_triple (const self_type &rhs)
 
BOOST_UBLAS_INLINE self_typeoperator= (const self_type &rhs)
 
BOOST_UBLAS_INLINE void swap (self_type &rhs)
 
BOOST_UBLAS_INLINE bool equal (const self_type &rhs) const
 
BOOST_UBLAS_INLINE bool less (const self_type &rhs) const
 
BOOST_UBLAS_INLINE index_triple_array (size_type size, V1 &data1, V2 &data2, V3 &data3)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE bool equal (size_type i1, size_type i2) const
 
BOOST_UBLAS_INLINE bool less (size_type i1, size_type i2) const
 
template<typename... Ts>
BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused (Ts const &...)
 
template<typename... Ts>
BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused ()
 
static BOOST_UBLAS_INLINE result_type apply (argument_type t)
 
static BOOST_UBLAS_INLINE result_type apply (argument_type t)
 
static BOOST_UBLAS_INLINE result_type apply (argument_type t)
 
static BOOST_UBLAS_INLINE result_type apply (argument_type t)
 
static BOOST_UBLAS_INLINE result_type apply (argument_type t)
 
static BOOST_UBLAS_INLINE result_type apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE result_type apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE result_type apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE result_type apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE void apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE void apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE void apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE void apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE void apply (argument1_type t1, argument2_type t2)
 
static BOOST_UBLAS_INLINE void apply (argument1_type t1, argument2_type t2)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E > &e)
 
template<class D , class I >
static BOOST_UBLAS_INLINE result_type apply (D size, I it)
 
template<class I >
static BOOST_UBLAS_INLINE result_type apply (I it, const I &it_end)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E > &e)
 
template<class D , class I >
static BOOST_UBLAS_INLINE result_type apply (D size, I it)
 
template<class I >
static BOOST_UBLAS_INLINE result_type apply (I it, const I &it_end)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E > &e)
 
template<class D , class I >
static BOOST_UBLAS_INLINE result_type apply (D size, I it)
 
template<class I >
static BOOST_UBLAS_INLINE result_type apply (I it, const I &it_end)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E > &e)
 
template<class D , class I >
static BOOST_UBLAS_INLINE result_type apply (D size, I it)
 
template<class I >
static BOOST_UBLAS_INLINE result_type apply (I it, const I &it_end)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E > &e)
 
template<class D , class I >
static BOOST_UBLAS_INLINE result_type apply (D size, I it)
 
template<class I >
static BOOST_UBLAS_INLINE result_type apply (I it, const I &it_end)
 
template<class C1 , class C2 >
static BOOST_UBLAS_INLINE result_type apply (const vector_container< C1 > &c1, const vector_container< C2 > &c2)
 
template<class E1 , class E2 >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class D , class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (D size, I1 it1, I2 it2)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag)
 
template<class C1 , class C2 >
static BOOST_UBLAS_INLINE result_type apply (const matrix_container< C1 > &c1, const vector_container< C2 > &c2, size_type i)
 
template<class E1 , class E2 >
static BOOST_UBLAS_INLINE result_type apply (const matrix_expression< E1 > &e1, const vector_expression< E2 > &e2, size_type i)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (difference_type size, I1 it1, I2 it2)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &, sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &, I2 it2, const I2 &it2_end, packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag)
 
template<class C1 , class C2 >
static BOOST_UBLAS_INLINE result_type apply (const vector_container< C1 > &c1, const matrix_container< C2 > &c2, size_type i)
 
template<class E1 , class E2 >
static BOOST_UBLAS_INLINE result_type apply (const vector_expression< E1 > &e1, const matrix_expression< E2 > &e2, size_type i)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (difference_type size, I1 it1, I2 it2)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &, I2 it2, const I2 &it2_end, packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &, sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag)
 
template<class C1 , class C2 >
static BOOST_UBLAS_INLINE result_type apply (const matrix_container< C1 > &c1, const matrix_container< C2 > &c2, size_type i, size_type j)
 
template<class E1 , class E2 >
static BOOST_UBLAS_INLINE result_type apply (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, size_type i, size_type j)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (difference_type size, I1 it1, I2 it2)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, packed_random_access_iterator_tag)
 
template<class I1 , class I2 >
static BOOST_UBLAS_INLINE result_type apply (I1 it1, const I1 &it1_end, I2 it2, const I2 &it2_end, sparse_bidirectional_iterator_tag)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const matrix_expression< E > &e)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const matrix_expression< E > &e)
 
template<class E >
static BOOST_UBLAS_INLINE result_type apply (const matrix_expression< E > &e)
 
static BOOST_UBLAS_INLINE size_type storage_size (size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type element (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type address (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE difference_type distance_i (difference_type k, size_type, size_type size_j)
 
static BOOST_UBLAS_INLINE difference_type distance_j (difference_type k, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type index_i (difference_type k, size_type, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type index_j (difference_type k, size_type, size_type size_j)
 
static BOOST_UBLAS_INLINE bool fast_i ()
 
static BOOST_UBLAS_INLINE bool fast_j ()
 
template<class I >
static BOOST_UBLAS_INLINE void increment_i (I &it, size_type, size_type size_j)
 
template<class I >
static BOOST_UBLAS_INLINE void increment_i (I &it, difference_type n, size_type, size_type size_j)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_i (I &it, size_type, size_type size_j)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_i (I &it, difference_type n, size_type, size_type size_j)
 
template<class I >
static BOOST_UBLAS_INLINE void increment_j (I &it, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void increment_j (I &it, difference_type n, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_j (I &it, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_j (I &it, difference_type n, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type triangular_size (size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type lower_element (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type upper_element (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type index_M (size_type index1, size_type)
 
static BOOST_UBLAS_INLINE size_type index_m (size_type, size_type index2)
 
static BOOST_UBLAS_INLINE size_type size_M (size_type size_i, size_type)
 
static BOOST_UBLAS_INLINE size_type size_m (size_type, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type storage_size (size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type element (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type address (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE difference_type distance_i (difference_type k, size_type, size_type)
 
static BOOST_UBLAS_INLINE difference_type distance_j (difference_type k, size_type size_i, size_type)
 
static BOOST_UBLAS_INLINE size_type index_i (difference_type k, size_type size_i, size_type)
 
static BOOST_UBLAS_INLINE size_type index_j (difference_type k, size_type size_i, size_type)
 
static BOOST_UBLAS_INLINE bool fast_i ()
 
static BOOST_UBLAS_INLINE bool fast_j ()
 
template<class I >
static BOOST_UBLAS_INLINE void increment_i (I &it, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void increment_i (I &it, difference_type n, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_i (I &it, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_i (I &it, difference_type n, size_type, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void increment_j (I &it, size_type size_i, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void increment_j (I &it, difference_type n, size_type size_i, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_j (I &it, size_type size_i, size_type)
 
template<class I >
static BOOST_UBLAS_INLINE void decrement_j (I &it, difference_type n, size_type size_i, size_type)
 
static BOOST_UBLAS_INLINE size_type triangular_size (size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type lower_element (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type upper_element (size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type index_M (size_type, size_type index2)
 
static BOOST_UBLAS_INLINE size_type index_m (size_type index1, size_type)
 
static BOOST_UBLAS_INLINE size_type size_M (size_type, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type size_m (size_type size_i, size_type)
 
template<class L >
static BOOST_UBLAS_INLINE size_type packed_size (L, size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE bool zero (size_type, size_type)
 
static BOOST_UBLAS_INLINE bool one (size_type, size_type)
 
static BOOST_UBLAS_INLINE bool other (size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type restrict1 (size_type i, size_type)
 
static BOOST_UBLAS_INLINE size_type restrict2 (size_type, size_type j)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict1 (size_type i, size_type)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict2 (size_type, size_type j)
 
template<class LAYOUT >
static BOOST_UBLAS_INLINE size_type packed_size (LAYOUT l, size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE bool zero (size_type i, size_type j)
 
static BOOST_UBLAS_INLINE bool one (size_type i, size_type j)
 
static BOOST_UBLAS_INLINE bool other (size_type i, size_type j)
 
template<class LAYOUT >
static BOOST_UBLAS_INLINE size_type element (LAYOUT, size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2)
 
static BOOST_UBLAS_INLINE size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type size2)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict2 (size_type i, size_type j, size_type size1, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_mutable_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2)
 
template<class L >
static BOOST_UBLAS_INLINE size_type packed_size (L, size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE bool zero (size_type i, size_type j)
 
static BOOST_UBLAS_INLINE bool one (size_type, size_type)
 
static BOOST_UBLAS_INLINE bool other (size_type i, size_type j)
 
template<class L >
static BOOST_UBLAS_INLINE size_type element (L, size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type restrict1 (size_type i, size_type j, size_type size1, size_type)
 
static BOOST_UBLAS_INLINE size_type restrict2 (size_type i, size_type j, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict2 (size_type i, size_type j, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type global_restrict1 (size_type index1, size_type size1, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type global_restrict2 (size_type, size_type, size_type index2, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type global_mutable_restrict2 (size_type, size_type, size_type index2, size_type size2)
 
template<class L >
static BOOST_UBLAS_INLINE size_type packed_size (L, size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE bool one (size_type i, size_type j)
 
static BOOST_UBLAS_INLINE bool other (size_type i, size_type j)
 
template<class L >
static BOOST_UBLAS_INLINE size_type element (L, size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict1 (size_type i, size_type j, size_type size1, size_type)
 
static BOOST_UBLAS_INLINE size_type mutable_restrict2 (size_type i, size_type j, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type global_mutable_restrict1 (size_type index1, size_type size1, size_type, size_type)
 
static BOOST_UBLAS_INLINE size_type global_mutable_restrict2 (size_type, size_type, size_type index2, size_type size2)
 
template<class L >
static BOOST_UBLAS_INLINE size_type packed_size (L, size_type size_i, size_type size_j)
 
static BOOST_UBLAS_INLINE bool zero (size_type i, size_type j)
 
static BOOST_UBLAS_INLINE bool one (size_type, size_type)
 
static BOOST_UBLAS_INLINE bool other (size_type i, size_type j)
 
template<class L >
static BOOST_UBLAS_INLINE size_type element (L, size_type i, size_type size_i, size_type j, size_type size_j)
 
static BOOST_UBLAS_INLINE size_type restrict1 (size_type i, size_type j, size_type size1, size_type size2)
 
static BOOST_UBLAS_INLINE size_type restrict2 (size_type i, size_type j, size_type size1, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_restrict1 (size_type index1, size_type size1, size_type index2, size_type size2)
 
static BOOST_UBLAS_INLINE size_type global_restrict2 (size_type index1, size_type size1, size_type index2, size_type size2)
 
BOOST_UBLAS_INLINE const expression_type & operator() () const
 
BOOST_UBLAS_INLINE expression_type & operator() ()
 
BOOST_UBLAS_INLINE scalar_reference (reference t)
 
BOOST_UBLAS_INLINE operator value_type () const
 
BOOST_UBLAS_INLINE scalar_referenceoperator= (const scalar_reference &s)
 
template<class AE >
BOOST_UBLAS_INLINE scalar_referenceoperator= (const scalar_expression< AE > &ae)
 
BOOST_UBLAS_INLINE bool same_closure (const scalar_reference &sr) const
 
BOOST_UBLAS_INLINE scalar_value (const value_type &t)
 
BOOST_UBLAS_INLINE operator value_type () const
 
BOOST_UBLAS_INLINE scalar_valueoperator= (const scalar_value &s)
 
template<class AE >
BOOST_UBLAS_INLINE scalar_valueoperator= (const scalar_expression< AE > &ae)
 
BOOST_UBLAS_INLINE bool same_closure (const scalar_value &sv) const
 
BOOST_UBLAS_INLINE const expression_type & operator() () const
 
BOOST_UBLAS_INLINE expression_type & operator() ()
 
BOOST_UBLAS_INLINE const container_type & operator() () const
 
BOOST_UBLAS_INLINE container_type & operator() ()
 
BOOST_UBLAS_INLINE const expression_type & operator() () const
 
BOOST_UBLAS_INLINE expression_type & operator() ()
 
BOOST_UBLAS_INLINE const container_type & operator() () const
 
BOOST_UBLAS_INLINE container_type & operator() ()
 
BOOST_UBLAS_INLINE vector_reference (referred_type &e)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const referred_type & expression () const
 
BOOST_UBLAS_INLINE referred_type & expression ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE vector_referenceoperator= (const vector_reference &v)
 
template<class AE >
BOOST_UBLAS_INLINE vector_referenceoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_referenceassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_referenceoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_referenceplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_referenceoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_referenceminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE vector_referenceoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE vector_referenceoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (vector_reference &v)
 
BOOST_UBLAS_INLINE bool same_closure (const vector_reference &vr) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
BOOST_UBLAS_INLINE vector_unary (expression_type &e)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const expression_closure_type & expression () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE bool same_closure (const vector_unary &vu) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vu, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
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)
 
BOOST_UBLAS_INLINE vector_binary (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE bool same_closure (const vector_binary &vb) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vb, size_type i, const const_subiterator1_type &it1, const const_subiterator1_type &it1_end, const const_subiterator2_type &it2, const const_subiterator2_type &it2_end)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
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)
 
BOOST_UBLAS_INLINE vector_binary_scalar1 (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE bool same_closure (const vector_binary_scalar1 &vbs1) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vbs, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
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)
 
BOOST_UBLAS_INLINE vector_binary_scalar2 (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE bool same_closure (const vector_binary_scalar2 &vbs2) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vbs, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
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)
 
BOOST_UBLAS_INLINE vector_scalar_unary (const expression_type &e)
 
BOOST_UBLAS_INLINE operator value_type () const
 
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)
 
BOOST_UBLAS_INLINE vector_scalar_binary (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE operator value_type () const
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE vector_scalar_binary_traits< E1, E2, vector_inner_prod< E1, E2, typename promote_traits< typename E1::value_type, typename E2::value_type >::promote_type > >::result_type inner_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE vector_scalar_binary_traits< E1, E2, vector_inner_prod< E1, E2, typename type_traits< typename promote_traits< typename E1::value_type, typename E2::value_type >::promote_type >::precision_type > >::result_type prec_inner_prod (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class E1 , class E2 , class S >
BOOST_UBLAS_INLINE bool equals (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2, S epsilon, S min_norm)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE bool expression_type_check (const vector_expression< E1 > &e1, const vector_expression< E2 > &e2)
 
template<class V , class E >
void make_conformant (V &v, const vector_expression< E > &e)
 
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)
 
BOOST_UBLAS_INLINE vector ()
 Constructor of a vector By default it is empty, i.e. size()==0.
 
BOOST_UBLAS_INLINE vector (size_type size)
 Constructor of a vector with a predefined size By default, its elements are initialized to 0. More...
 
BOOST_UBLAS_INLINE vector (size_type, const array_type &data)
 Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition. More...
 
BOOST_UBLAS_INLINE vector (const array_type &data)
 Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition. More...
 
BOOST_UBLAS_INLINE vector (size_type size, const value_type &init)
 Constructor of a vector with a predefined size and a unique initial value. More...
 
BOOST_UBLAS_INLINE vector (const vector &v)
 Copy-constructor of a vector. More...
 
template<class AE >
BOOST_UBLAS_INLINE vector (const vector_expression< AE > &ae)
 Copy-constructor of a vector from a vector_expression Depending on the vector_expression, this constructor can have the cost of the computations of the expression (trivial to say it, but it is to take into account in your complexity calculations). More...
 
BOOST_UBLAS_INLINE size_type max_size () const
 Return the maximum size of the data container. Return the upper bound (maximum size) on the data container. Depending on the container, it can be bigger than the current size of the vector.
 
BOOST_UBLAS_INLINE bool empty () const
 Return true if the vector is empty (size==0) More...
 
BOOST_UBLAS_INLINE size_type size () const
 Return the size of the vector.
 
BOOST_UBLAS_INLINE const array_type & data () const
 Return a const reference to the container. Useful to access data directly for specific type of container.
 
BOOST_UBLAS_INLINE array_type & data ()
 Return a reference to the container. Useful to speed-up write operations to the data in very specific case.
 
BOOST_UBLAS_INLINE void resize (size_type size, bool preserve=true)
 Resize the vector Resize the vector to a new size. If preserve is true, data are copied otherwise data are lost. If the new size is bigger, the remaining values are filled in with the initial value (0 by default) in the case of unbounded_array, which is the container by default. If the new size is smaller, last values are lost. This behaviour can be different if you explicitely specify another type of container. More...
 
BOOST_UBLAS_INLINE pointer find_element (size_type i)
 Return a pointer to the element $i$. More...
 
BOOST_UBLAS_INLINE const_pointer find_element (size_type i) const
 Return a const pointer to the element $i$. More...
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 Return a const reference to the element $i$ Return a const reference to the element $i$. With some compilers, this notation will be faster than [i]. More...
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 Return a reference to the element $i$ Return a reference to the element $i$. With some compilers, this notation will be faster than [i]. More...
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 Return a const reference to the element $i$. More...
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 Return a reference to the element $i$. More...
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, const_reference t)
 Set element $i$ to the value t. More...
 
BOOST_UBLAS_INLINE void erase_element (size_type i)
 Set element $i$ to the zero value. More...
 
BOOST_UBLAS_INLINE void clear ()
 Clear the vector, i.e. set all values to the zero value.
 
BOOST_UBLAS_INLINE vectoroperator= (const vector &v)
 Assign a full vector (RHS-vector) to the current vector (LHS-vector) More...
 
template<class C >
BOOST_UBLAS_INLINE vectoroperator= (const vector_container< C > &v)
 Assign a full vector (RHS-vector) to the current vector (LHS-vector) Assign a full vector (RHS-vector) to the current vector (LHS-vector). This method does not create any temporary. More...
 
BOOST_UBLAS_INLINE vectorassign_temporary (vector &v)
 Assign a full vector (RHS-vector) to the current vector (LHS-vector) More...
 
template<class AE >
BOOST_UBLAS_INLINE vectoroperator= (const vector_expression< AE > &ae)
 Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. More...
 
template<class AE >
BOOST_UBLAS_INLINE vectorassign (const vector_expression< AE > &ae)
 Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. More...
 
template<class AE >
BOOST_UBLAS_INLINE vectoroperator+= (const vector_expression< AE > &ae)
 Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations. More...
 
template<class C >
BOOST_UBLAS_INLINE vectoroperator+= (const vector_container< C > &v)
 Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector. More...
 
template<class AE >
BOOST_UBLAS_INLINE vectorplus_assign (const vector_expression< AE > &ae)
 Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector. More...
 
template<class AE >
BOOST_UBLAS_INLINE vectoroperator-= (const vector_expression< AE > &ae)
 Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations. More...
 
template<class C >
BOOST_UBLAS_INLINE vectoroperator-= (const vector_container< C > &v)
 Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector. More...
 
template<class AE >
BOOST_UBLAS_INLINE vectorminus_assign (const vector_expression< AE > &ae)
 Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector. More...
 
template<class AT >
BOOST_UBLAS_INLINE vectoroperator*= (const AT &at)
 Assign the product of the vector and a scalar to the vector Assign the product of the vector and a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector. More...
 
template<class AT >
BOOST_UBLAS_INLINE vectoroperator/= (const AT &at)
 Assign the division of the vector by a scalar to the vector Assign the division of the vector by a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector. More...
 
BOOST_UBLAS_INLINE void swap (vector &v)
 Swap the content of the vector with another vector. More...
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 Return a const iterator to the element i. More...
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 Return an iterator to the element i. More...
 
BOOST_UBLAS_INLINE const_iterator (const self_type &v, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 Increment by 1 the position of the iterator. More...
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 Decrement by 1 the position of the iterator. More...
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 Increment by n the position of the iterator. More...
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 Decrement by n the position of the iterator. More...
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 Return the different in number of positions between 2 iterators.
 
BOOST_UBLAS_INLINE const_reference operator* () const
 Dereference an iterator Dereference an iterator: a bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds. More...
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 Dereference an iterator at the n-th forward value Dereference an iterator at the n-th forward value, that is the value pointed by iterator+n. More...
 
BOOST_UBLAS_INLINE size_type index () const
 return the index of the element referenced by the iterator
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 assign the value of an iterator to the iterator
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 compare the value of two itetarors More...
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 compare the value of two iterators More...
 
BOOST_UBLAS_INLINE const_iterator begin () const
 return an iterator on the first element of the vector
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 return an iterator on the first element of the vector
 
BOOST_UBLAS_INLINE const_iterator end () const
 return an iterator after the last element of the vector
 
BOOST_UBLAS_INLINE const_iterator cend () const
 return an iterator after the last element of the vector
 
BOOST_UBLAS_INLINE iterator (self_type &v, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 Return an iterator on the first element of the vector.
 
BOOST_UBLAS_INLINE iterator end ()
 Return an iterator at the end of the vector.
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE bounded_vector (size_type size)
 
BOOST_UBLAS_INLINE bounded_vector (const bounded_vector &v)
 
template<class A2 >
BOOST_UBLAS_INLINE bounded_vector (const vector< T, A2 > &v)
 
template<class AE >
BOOST_UBLAS_INLINE bounded_vector (const vector_expression< AE > &ae)
 
BOOST_UBLAS_INLINE bounded_vectoroperator= (const bounded_vector &v)
 
template<class A2 >
BOOST_UBLAS_INLINE bounded_vectoroperator= (const vector< T, A2 > &v)
 
template<class C >
BOOST_UBLAS_INLINE bounded_vectoroperator= (const vector_container< C > &v)
 
template<class AE >
BOOST_UBLAS_INLINE bounded_vectoroperator= (const vector_expression< AE > &ae)
 
BOOST_UBLAS_INLINE zero_vector (size_type size)
 
BOOST_UBLAS_INLINE zero_vector (const zero_vector &v)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE void resize (size_type size, bool=true)
 
BOOST_UBLAS_INLINE const_pointer find_element (size_type) const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type) const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE zero_vectoroperator= (const zero_vector &v)
 
BOOST_UBLAS_INLINE zero_vectorassign_temporary (zero_vector &v)
 
BOOST_UBLAS_INLINE void swap (zero_vector &v)
 
BOOST_UBLAS_INLINE const_iterator find (size_type) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &v)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE unit_vector ()
 Simple constructor with dimension and index 0.
 
BOOST_UBLAS_INLINE unit_vector (size_type size, size_type index=0)
 Constructor of unit_vector. More...
 
BOOST_UBLAS_INLINE unit_vector (const unit_vector &v)
 Copy-constructor.
 
BOOST_UBLAS_INLINE size_type size () const
 Return the size (dimension) of the vector.
 
BOOST_UBLAS_INLINE size_type index () const
 Return the order of the unit vector.
 
BOOST_UBLAS_INLINE void resize (size_type size, bool=true)
 Resize the vector. The values are preserved by default (i.e. the index does not change) More...
 
BOOST_UBLAS_INLINE const_pointer find_element (size_type i) const
 Return a const pointer to the element of index i.
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE unit_vectoroperator= (const unit_vector &v)
 
BOOST_UBLAS_INLINE unit_vectorassign_temporary (unit_vector &v)
 
BOOST_UBLAS_INLINE void swap (unit_vector &v)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const unit_vector &v, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE scalar_vector (size_type size, const value_type &value=value_type(1))
 
BOOST_UBLAS_INLINE scalar_vector (const scalar_vector &v)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE void resize (size_type size, bool=true)
 
BOOST_UBLAS_INLINE const_pointer find_element (size_type) const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type) const
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type) const
 
BOOST_UBLAS_INLINE scalar_vectoroperator= (const scalar_vector &v)
 
BOOST_UBLAS_INLINE scalar_vectorassign_temporary (scalar_vector &v)
 
BOOST_UBLAS_INLINE void swap (scalar_vector &v)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const scalar_vector &v, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE c_vector (size_type size)
 
BOOST_UBLAS_INLINE c_vector (const c_vector &v)
 
template<class AE >
BOOST_UBLAS_INLINE c_vector (const vector_expression< AE > &ae)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_pointer data () const
 
BOOST_UBLAS_INLINE pointer data ()
 
BOOST_UBLAS_INLINE void resize (size_type size, bool=true)
 
BOOST_UBLAS_INLINE pointer find_element (size_type i)
 
BOOST_UBLAS_INLINE const_pointer find_element (size_type i) const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, const_reference t)
 
BOOST_UBLAS_INLINE void erase_element (size_type i)
 
BOOST_UBLAS_INLINE void clear ()
 
BOOST_UBLAS_INLINE c_vectoroperator= (const c_vector &v)
 
template<class C >
BOOST_UBLAS_INLINE c_vectoroperator= (const vector_container< C > &v)
 
BOOST_UBLAS_INLINE c_vectorassign_temporary (c_vector &v)
 
template<class AE >
BOOST_UBLAS_INLINE c_vectoroperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE c_vectorassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE c_vectoroperator+= (const vector_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE c_vectoroperator+= (const vector_container< C > &v)
 
template<class AE >
BOOST_UBLAS_INLINE c_vectorplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE c_vectoroperator-= (const vector_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE c_vectoroperator-= (const vector_container< C > &v)
 
template<class AE >
BOOST_UBLAS_INLINE c_vectorminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE c_vectoroperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE c_vectoroperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (c_vector &v)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
BOOST_UBLAS_INLINE const_iterator (const self_type &v, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator (self_type &v, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE matrix_reference (referred_type &e)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const referred_type & expression () const
 
BOOST_UBLAS_INLINE referred_type & expression ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE matrix_referenceoperator= (const matrix_reference &m)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_referenceoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_referenceassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_referenceoperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_referenceplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_referenceoperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_referenceminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_referenceoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_referenceoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (matrix_reference &m)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_reference &mr) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
BOOST_UBLAS_INLINE vector_matrix_binary (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const expression1_closure_type & expression1 () const
 
BOOST_UBLAS_INLINE const expression2_closure_type & expression2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const vector_matrix_binary &vmb) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
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)
 
BOOST_UBLAS_INLINE matrix_unary1 (const expression_type &e)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const expression_closure_type & expression () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_unary1 &mu1) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mu, const const_subiterator1_type &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mu, const const_subiterator2_type &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
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)
 
BOOST_UBLAS_INLINE matrix_unary2 (expression_type &e)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const expression_closure_type & expression () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_unary2 &mu2) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mu, const const_subiterator1_type &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mu, const const_subiterator2_type &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
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)
 
BOOST_UBLAS_INLINE matrix_binary (const E1 &e1, const E2 &e2)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const expression1_closure_type & expression1 () const
 
BOOST_UBLAS_INLINE const expression2_closure_type & expression2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_binary &mb) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mb, size_type i, size_type j, const const_iterator11_type &it1, const const_iterator11_type &it1_end, const const_iterator21_type &it2, const const_iterator21_type &it2_end)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mb, size_type i, size_type j, const const_iterator12_type &it1, const const_iterator12_type &it1_end, const const_iterator22_type &it2, const const_iterator22_type &it2_end)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
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)
 
BOOST_UBLAS_INLINE matrix_binary_scalar1 (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_binary_scalar1 &mbs1) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mbs, const const_subiterator1_type &it1, const const_iterator21_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mbs, const const_subiterator1_type &it1, const const_iterator22_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
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)
 
BOOST_UBLAS_INLINE matrix_binary_scalar2 (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_binary_scalar2 &mbs2) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mbs, const const_iterator11_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mbs, const const_iterator12_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
template<class E1 , class T2 >
BOOST_UBLAS_INLINE enable_if< is_convertible< T2, typename E1::value_type >, typename matrix_binary_scalar2_traits< E1, const T2, scalar_multiplies< typename E1::value_type, T2 > >::result_type >::type operator* (const matrix_expression< E1 > &e1, const T2 &e2)
 
template<class E1 , class T2 >
BOOST_UBLAS_INLINE enable_if< is_convertible< T2, typename E1::value_type >, typename matrix_binary_scalar2_traits< E1, const T2, scalar_divides< typename E1::value_type, T2 > >::result_type >::type operator/ (const matrix_expression< E1 > &e1, const T2 &e2)
 
BOOST_UBLAS_INLINE matrix_vector_binary1 (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const expression1_closure_type & expression1 () const
 
BOOST_UBLAS_INLINE const expression2_closure_type & expression2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_vector_binary1 &mvb1) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mvb, const const_subiterator1_type &it1)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
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)
 
BOOST_UBLAS_INLINE matrix_vector_binary2 (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const expression1_closure_type & expression1 () const
 
BOOST_UBLAS_INLINE const expression2_closure_type & expression2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_vector_binary2 &mvb2) const
 
BOOST_UBLAS_INLINE const_iterator find (size_type j) const
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mvb, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
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)
 
BOOST_UBLAS_INLINE matrix_matrix_binary (const expression1_type &e1, const expression2_type &e2)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const expression1_closure_type & expression1 () const
 
BOOST_UBLAS_INLINE const expression2_closure_type & expression2 () const
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_matrix_binary &mmb) const
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
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)
 
BOOST_UBLAS_INLINE matrix_scalar_unary (const expression_type &e)
 
BOOST_UBLAS_INLINE operator value_type () const
 
template<class E >
BOOST_UBLAS_INLINE matrix_scalar_unary_traits< E, matrix_norm_1< E > >::result_type norm_1 (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE matrix_scalar_unary_traits< E, matrix_norm_frobenius< E > >::result_type norm_frobenius (const matrix_expression< E > &e)
 
template<class E >
BOOST_UBLAS_INLINE matrix_scalar_unary_traits< E, matrix_norm_inf< E > >::result_type norm_inf (const matrix_expression< E > &e)
 
template<class E1 , class E2 , class S >
BOOST_UBLAS_INLINE bool equals (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2, S epsilon, S min_norm)
 
template<class E1 , class E2 >
BOOST_UBLAS_INLINE bool expression_type_check (const matrix_expression< E1 > &e1, const matrix_expression< E2 > &e2)
 
template<class M , class E , class R >
void make_conformant (M &m, const matrix_expression< E > &e, row_major_tag, R)
 
template<class M , class E , class R >
void make_conformant (M &m, const matrix_expression< E > &e, column_major_tag, R)
 
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 L , class M >
BOOST_UBLAS_INLINE void matrix_resize_preserve (M &m, M &temporary)
 
BOOST_UBLAS_INLINE matrix ()
 Default dense matrix constructor. Make a dense matrix of size (0,0)
 
BOOST_UBLAS_INLINE matrix (size_type size1, size_type size2)
 
 matrix (size_type size1, size_type size2, const value_type &init)
 
BOOST_UBLAS_INLINE matrix (size_type size1, size_type size2, const array_type &data)
 
BOOST_UBLAS_INLINE matrix (const matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE matrix (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const array_type & data () const
 
BOOST_UBLAS_INLINE array_type & data ()
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool preserve=true)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference at_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, size_type j, const_reference t)
 
void erase_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE void clear ()
 
BOOST_UBLAS_INLINE matrixoperator= (const matrix &m)
 
template<class C >
BOOST_UBLAS_INLINE matrixoperator= (const matrix_container< C > &m)
 
BOOST_UBLAS_INLINE matrixassign_temporary (matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE matrixoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrixassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrixoperator+= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE matrixoperator+= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE matrixplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrixoperator-= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE matrixoperator-= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE matrixminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrixoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrixoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE bounded_matrix (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE bounded_matrix (const bounded_matrix &m)
 
template<class A2 >
BOOST_UBLAS_INLINE bounded_matrix (const matrix< T, L, A2 > &m)
 
template<class AE >
BOOST_UBLAS_INLINE bounded_matrix (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE bounded_matrixoperator= (const bounded_matrix &m)
 
template<class L2 , class A2 >
BOOST_UBLAS_INLINE bounded_matrixoperator= (const matrix< T, L2, A2 > &m)
 
template<class C >
BOOST_UBLAS_INLINE bounded_matrixoperator= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE bounded_matrixoperator= (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE vector_of_vector (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE vector_of_vector (const vector_of_vector &m)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vector (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const array_type & data () const
 
BOOST_UBLAS_INLINE array_type & data ()
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool preserve=true)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference at_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, size_type j, const_reference t)
 
BOOST_UBLAS_INLINE void erase_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE void clear ()
 
BOOST_UBLAS_INLINE vector_of_vectoroperator= (const vector_of_vector &m)
 
BOOST_UBLAS_INLINE vector_of_vectorassign_temporary (vector_of_vector &m)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vectoroperator= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE vector_of_vectoroperator= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vectorassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vectoroperator+= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE vector_of_vectoroperator+= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vectorplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vectoroperator-= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE vector_of_vectoroperator-= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE vector_of_vectorminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE vector_of_vectoroperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE vector_of_vectoroperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (vector_of_vector &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, size_type i, size_type j, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, size_type i, size_type j, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, size_type i, size_type j, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, size_type i, size_type j, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE zero_matrix (size_type size)
 
BOOST_UBLAS_INLINE zero_matrix (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE zero_matrix (const zero_matrix &m)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE void resize (size_type size, bool=true)
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool=true)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type, size_type) const
 
BOOST_UBLAS_INLINE zero_matrixoperator= (const zero_matrix &m)
 
BOOST_UBLAS_INLINE zero_matrixassign_temporary (zero_matrix &m)
 
BOOST_UBLAS_INLINE void swap (zero_matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type, size_type) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type, size_type) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE identity_matrix (size_type size)
 
BOOST_UBLAS_INLINE identity_matrix (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE identity_matrix (const identity_matrix &m)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE void resize (size_type size, bool=true)
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool=true)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE identity_matrixoperator= (const identity_matrix &m)
 
BOOST_UBLAS_INLINE identity_matrixassign_temporary (identity_matrix &m)
 
BOOST_UBLAS_INLINE void swap (identity_matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE scalar_matrix (size_type size1, size_type size2, const value_type &value=value_type(1))
 
BOOST_UBLAS_INLINE scalar_matrix (const scalar_matrix &m)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool=true)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type, size_type) const
 
BOOST_UBLAS_INLINE scalar_matrixoperator= (const scalar_matrix &m)
 
BOOST_UBLAS_INLINE scalar_matrixassign_temporary (scalar_matrix &m)
 
BOOST_UBLAS_INLINE void swap (scalar_matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE const_iterator1 (const scalar_matrix &m, const const_subiterator_type &it1, const const_subiterator_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE const_iterator2 (const scalar_matrix &m, const const_subiterator_type &it1, const const_subiterator_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE c_matrix (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE c_matrix (const c_matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrix (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const_pointer data () const
 
BOOST_UBLAS_INLINE pointer data ()
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool preserve=true)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference at_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, size_type j, const_reference t)
 
BOOST_UBLAS_INLINE void clear ()
 
BOOST_UBLAS_INLINE c_matrixoperator= (const c_matrix &m)
 
template<class C >
BOOST_UBLAS_INLINE c_matrixoperator= (const matrix_container< C > &m)
 
BOOST_UBLAS_INLINE c_matrixassign_temporary (c_matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrixoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrixassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrixoperator+= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE c_matrixoperator+= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrixplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrixoperator-= (const matrix_expression< AE > &ae)
 
template<class C >
BOOST_UBLAS_INLINE c_matrixoperator-= (const matrix_container< C > &m)
 
template<class AE >
BOOST_UBLAS_INLINE c_matrixminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE c_matrixoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE c_matrixoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (c_matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
template<class Archive >
void serialize (Archive &ar, const unsigned int)
 
BOOST_UBLAS_INLINE matrix_row (matrix_type &data, size_type i)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type j)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type j) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type j)
 
BOOST_UBLAS_INLINE matrix_rowoperator= (const matrix_row &mr)
 
BOOST_UBLAS_INLINE matrix_rowassign_temporary (matrix_row &mr)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rowoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rowassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rowoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rowplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rowoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rowminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_rowoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_rowoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_row &mr) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_row &mr) const
 
BOOST_UBLAS_INLINE void swap (matrix_row mr)
 
BOOST_UBLAS_INLINE const_iterator find (size_type j) const
 
BOOST_UBLAS_INLINE iterator find (size_type j)
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mr, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator (self_type &mr, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
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)
 
BOOST_UBLAS_INLINE matrix_column (matrix_type &data, size_type j)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE matrix_columnoperator= (const matrix_column &mc)
 
BOOST_UBLAS_INLINE matrix_columnassign_temporary (matrix_column &mc)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_columnoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_columnassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_columnoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_columnplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_columnoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_columnminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_columnoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_columnoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_column &mc) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_column &mc) const
 
BOOST_UBLAS_INLINE void swap (matrix_column mc)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mc, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator (self_type &mc, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
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)
 
BOOST_UBLAS_INLINE matrix_vector_range (matrix_type &data, const range_type &r1, const range_type &r2)
 
BOOST_UBLAS_INLINE size_type start1 () const
 
BOOST_UBLAS_INLINE size_type start2 () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE matrix_vector_rangeoperator= (const matrix_vector_range &mvr)
 
BOOST_UBLAS_INLINE matrix_vector_rangeassign_temporary (matrix_vector_range &mvr)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_rangeoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_rangeassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_rangeoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_rangeplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_rangeoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_rangeminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_vector_rangeoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_vector_rangeoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_vector_range &mvr) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_vector_range &mvr) const
 
BOOST_UBLAS_INLINE void swap (matrix_vector_range mvr)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
 BOOST_STATIC_ASSERT ((boost::is_same< typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category >::value))
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mvr, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
 BOOST_STATIC_ASSERT ((boost::is_same< typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category >::value))
 
BOOST_UBLAS_INLINE iterator (self_type &mvr, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
BOOST_UBLAS_INLINE matrix_vector_slice (matrix_type &data, const slice_type &s1, const slice_type &s2)
 
BOOST_UBLAS_INLINE size_type start1 () const
 
BOOST_UBLAS_INLINE size_type start2 () const
 
BOOST_UBLAS_INLINE difference_type stride1 () const
 
BOOST_UBLAS_INLINE difference_type stride2 () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE matrix_vector_sliceoperator= (const matrix_vector_slice &mvs)
 
BOOST_UBLAS_INLINE matrix_vector_sliceassign_temporary (matrix_vector_slice &mvs)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_sliceoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_sliceassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_sliceoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_sliceplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_sliceoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_sliceminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_vector_sliceoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_vector_sliceoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_vector_slice &mvs) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_vector_slice &mvs) const
 
BOOST_UBLAS_INLINE void swap (matrix_vector_slice mvs)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
 BOOST_STATIC_ASSERT ((boost::is_same< typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category >::value))
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mvs, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
 BOOST_STATIC_ASSERT ((boost::is_same< typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category >::value))
 
BOOST_UBLAS_INLINE iterator (self_type &mvs, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
BOOST_UBLAS_INLINE matrix_vector_indirect (matrix_type &data, size_type size)
 
BOOST_UBLAS_INLINE matrix_vector_indirect (matrix_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const indirect_array_type & indirect1 () const
 
BOOST_UBLAS_INLINE indirect_array_type & indirect1 ()
 
BOOST_UBLAS_INLINE const indirect_array_type & indirect2 () const
 
BOOST_UBLAS_INLINE indirect_array_type & indirect2 ()
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE matrix_vector_indirectoperator= (const matrix_vector_indirect &mvi)
 
BOOST_UBLAS_INLINE matrix_vector_indirectassign_temporary (matrix_vector_indirect &mvi)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_indirectoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_indirectassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_indirectoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_indirectplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_indirectoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_vector_indirectminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_vector_indirectoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_vector_indirectoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_vector_indirect &mvi) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_vector_indirect &mvi) const
 
BOOST_UBLAS_INLINE void swap (matrix_vector_indirect mvi)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
 BOOST_STATIC_ASSERT ((boost::is_same< typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category >::value))
 
BOOST_UBLAS_INLINE const_iterator (const self_type &mvi, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
 BOOST_STATIC_ASSERT ((boost::is_same< typename M::const_iterator1::iterator_category, typename M::const_iterator2::iterator_category >::value))
 
BOOST_UBLAS_INLINE iterator (self_type &mvi, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
BOOST_UBLAS_INLINE matrix_range (matrix_type &data, const range_type &r1, const range_type &r2)
 
BOOST_UBLAS_INLINE matrix_range (const matrix_closure_type &data, const range_type &r1, const range_type &r2, int)
 
BOOST_UBLAS_INLINE size_type start1 () const
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type start2 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE matrix_range< matrix_type > project (const range_type &r1, const range_type &r2) const
 
BOOST_UBLAS_INLINE matrix_rangeoperator= (const matrix_range &mr)
 
BOOST_UBLAS_INLINE matrix_rangeassign_temporary (matrix_range &mr)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rangeoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rangeassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rangeoperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rangeplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rangeoperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_rangeminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_rangeoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_rangeoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_range &mr) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_range &mr) const
 
BOOST_UBLAS_INLINE void swap (matrix_range mr)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mr, const const_subiterator1_type &it)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &mr, const subiterator1_type &it)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mr, const const_subiterator2_type &it)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &mr, const subiterator2_type &it)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
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)
 
BOOST_UBLAS_INLINE matrix_slice (matrix_type &data, const slice_type &s1, const slice_type &s2)
 
BOOST_UBLAS_INLINE matrix_slice (const matrix_closure_type &data, const slice_type &s1, const slice_type &s2, int)
 
BOOST_UBLAS_INLINE size_type start1 () const
 
BOOST_UBLAS_INLINE size_type start2 () const
 
BOOST_UBLAS_INLINE difference_type stride1 () const
 
BOOST_UBLAS_INLINE difference_type stride2 () const
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE matrix_slice< matrix_type > project (const range_type &r1, const range_type &r2) const
 
BOOST_UBLAS_INLINE matrix_slice< matrix_type > project (const slice_type &s1, const slice_type &s2) const
 
BOOST_UBLAS_INLINE matrix_sliceoperator= (const matrix_slice &ms)
 
BOOST_UBLAS_INLINE matrix_sliceassign_temporary (matrix_slice &ms)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_sliceoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_sliceassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_sliceoperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_sliceplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_sliceoperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_sliceminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_sliceoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_sliceoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_slice &ms) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_slice &ms) const
 
BOOST_UBLAS_INLINE void swap (matrix_slice ms)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &ms, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &ms, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &ms, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &ms, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
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)
 
BOOST_UBLAS_INLINE matrix_indirect (matrix_type &data, size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE matrix_indirect (matrix_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2)
 
BOOST_UBLAS_INLINE matrix_indirect (const matrix_closure_type &data, const indirect_array_type &ia1, const indirect_array_type &ia2, int)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const indirect_array_type & indirect1 () const
 
BOOST_UBLAS_INLINE indirect_array_type & indirect1 ()
 
BOOST_UBLAS_INLINE const indirect_array_type & indirect2 () const
 
BOOST_UBLAS_INLINE indirect_array_type & indirect2 ()
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE matrix_indirect< matrix_type, indirect_array_type > project (const range_type &r1, const range_type &r2) const
 
BOOST_UBLAS_INLINE matrix_indirect< matrix_type, indirect_array_type > project (const slice_type &s1, const slice_type &s2) const
 
BOOST_UBLAS_INLINE matrix_indirect< matrix_type, indirect_array_type > project (const indirect_array_type &ia1, const indirect_array_type &ia2) const
 
BOOST_UBLAS_INLINE matrix_indirectoperator= (const matrix_indirect &mi)
 
BOOST_UBLAS_INLINE matrix_indirectassign_temporary (matrix_indirect &mi)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_indirectoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_indirectassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_indirectoperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_indirectplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_indirectoperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE matrix_indirectminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_indirectoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE matrix_indirectoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const matrix_indirect &mi) const
 
BOOST_UBLAS_INLINE bool operator== (const matrix_indirect &mi) const
 
BOOST_UBLAS_INLINE void swap (matrix_indirect mi)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &mi, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &mi, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &mi, const const_subiterator1_type &it1, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &mi, const subiterator1_type &it1, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
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)
 
BOOST_UBLAS_INLINE vector_range (vector_type &data, const range_type &r)
 
BOOST_UBLAS_INLINE vector_range (const vector_closure_type &data, const range_type &r, bool)
 
BOOST_UBLAS_INLINE size_type start () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const vector_closure_type & data () const
 
BOOST_UBLAS_INLINE vector_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE vector_range< vector_type > project (const range_type &r) const
 
BOOST_UBLAS_INLINE vector_rangeoperator= (const vector_range &vr)
 
BOOST_UBLAS_INLINE vector_rangeassign_temporary (vector_range &vr)
 
template<class AE >
BOOST_UBLAS_INLINE vector_rangeoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_rangeassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_rangeoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_rangeplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_rangeoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_rangeminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE vector_rangeoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE vector_rangeoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const vector_range &vr) const
 
BOOST_UBLAS_INLINE bool operator== (const vector_range &vr) const
 
BOOST_UBLAS_INLINE void swap (vector_range vr)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vr, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator (self_type &vr, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
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.
 
BOOST_UBLAS_INLINE vector_slice (vector_type &data, const slice_type &s)
 
BOOST_UBLAS_INLINE vector_slice (const vector_closure_type &data, const slice_type &s, int)
 
BOOST_UBLAS_INLINE size_type start () const
 
BOOST_UBLAS_INLINE difference_type stride () const
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const vector_closure_type & data () const
 
BOOST_UBLAS_INLINE vector_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE vector_slice< vector_type > project (const range_type &r) const
 
BOOST_UBLAS_INLINE vector_slice< vector_type > project (const slice_type &s) const
 
BOOST_UBLAS_INLINE vector_sliceoperator= (const vector_slice &vs)
 
BOOST_UBLAS_INLINE vector_sliceassign_temporary (vector_slice &vs)
 
template<class AE >
BOOST_UBLAS_INLINE vector_sliceoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_sliceassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_sliceoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_sliceplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_sliceoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_sliceminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE vector_sliceoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE vector_sliceoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const vector_slice &vr) const
 
BOOST_UBLAS_INLINE bool operator== (const vector_slice &vs) const
 
BOOST_UBLAS_INLINE void swap (vector_slice vs)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vs, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator (self_type &vs, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
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)
 
BOOST_UBLAS_INLINE vector_indirect (vector_type &data, size_type size)
 
BOOST_UBLAS_INLINE vector_indirect (vector_type &data, const indirect_array_type &ia)
 
BOOST_UBLAS_INLINE vector_indirect (const vector_closure_type &data, const indirect_array_type &ia, int)
 
BOOST_UBLAS_INLINE size_type size () const
 
BOOST_UBLAS_INLINE const_indirect_array_type & indirect () const
 
BOOST_UBLAS_INLINE indirect_array_type & indirect ()
 
BOOST_UBLAS_INLINE const vector_closure_type & data () const
 
BOOST_UBLAS_INLINE vector_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i)
 
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 
BOOST_UBLAS_INLINE vector_indirect< vector_type, indirect_array_type > project (const range_type &r) const
 
BOOST_UBLAS_INLINE vector_indirect< vector_type, indirect_array_type > project (const slice_type &s) const
 
BOOST_UBLAS_INLINE vector_indirect< vector_type, indirect_array_type > project (const indirect_array_type &ia) const
 
BOOST_UBLAS_INLINE vector_indirectoperator= (const vector_indirect &vi)
 
BOOST_UBLAS_INLINE vector_indirectassign_temporary (vector_indirect &vi)
 
template<class AE >
BOOST_UBLAS_INLINE vector_indirectoperator= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_indirectassign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_indirectoperator+= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_indirectplus_assign (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_indirectoperator-= (const vector_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE vector_indirectminus_assign (const vector_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE vector_indirectoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE vector_indirectoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const vector_indirect &) const
 
BOOST_UBLAS_INLINE bool operator== (const vector_indirect &vi) const
 
BOOST_UBLAS_INLINE void swap (vector_indirect vi)
 
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 
BOOST_UBLAS_INLINE iterator find (size_type i)
 
BOOST_UBLAS_INLINE const_iterator (const self_type &vi, const const_subiterator_type &it)
 
BOOST_UBLAS_INLINE const_iterator (const typename self_type::iterator &it)
 
BOOST_UBLAS_INLINE const_iteratoroperator++ ()
 
BOOST_UBLAS_INLINE const_iteratoroperator-- ()
 
BOOST_UBLAS_INLINE const_iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE const_iteratoroperator= (const const_iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator &it) const
 
BOOST_UBLAS_INLINE const_iterator begin () const
 
BOOST_UBLAS_INLINE const_iterator cbegin () const
 
BOOST_UBLAS_INLINE const_iterator end () const
 
BOOST_UBLAS_INLINE const_iterator cend () const
 
BOOST_UBLAS_INLINE iterator (self_type &vi, const subiterator_type &it)
 
BOOST_UBLAS_INLINE iteratoroperator++ ()
 
BOOST_UBLAS_INLINE iteratoroperator-- ()
 
BOOST_UBLAS_INLINE iteratoroperator+= (difference_type n)
 
BOOST_UBLAS_INLINE iteratoroperator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE size_type index () const
 
BOOST_UBLAS_INLINE iteratoroperator= (const iterator &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator &it) const
 
BOOST_UBLAS_INLINE iterator begin ()
 
BOOST_UBLAS_INLINE iterator end ()
 
BOOST_UBLAS_INLINE const_reverse_iterator rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator crend () const
 
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 
BOOST_UBLAS_INLINE reverse_iterator rend ()
 
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 L , class T , class M >
BOOST_UBLAS_INLINE void matrix_resize_preserve (M &m, M &temporary)
 
BOOST_UBLAS_INLINE triangular_matrix (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE triangular_matrix (size_type size1, size_type size2, const array_type &data)
 
BOOST_UBLAS_INLINE triangular_matrix (const triangular_matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrix (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const array_type & data () const
 
BOOST_UBLAS_INLINE array_type & data ()
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool preserve=true)
 
BOOST_UBLAS_INLINE void resize_packed_preserve (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference at_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, size_type j, const_reference t)
 
BOOST_UBLAS_INLINE void erase_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE void clear ()
 
BOOST_UBLAS_INLINE triangular_matrixoperator= (const triangular_matrix &m)
 
BOOST_UBLAS_INLINE triangular_matrixassign_temporary (triangular_matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrixoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrixassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrixoperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrixplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrixoperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_matrixminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE triangular_matrixoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE triangular_matrixoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (triangular_matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
BOOST_UBLAS_INLINE triangular_adaptor (matrix_type &data)
 
BOOST_UBLAS_INLINE triangular_adaptor (const triangular_adaptor &m)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE triangular_adaptoroperator= (const triangular_adaptor &m)
 
BOOST_UBLAS_INLINE triangular_adaptorassign_temporary (triangular_adaptor &m)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_adaptoroperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_adaptorassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_adaptoroperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_adaptorplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_adaptoroperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE triangular_adaptorminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE triangular_adaptoroperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE triangular_adaptoroperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const triangular_adaptor &ta) const
 
BOOST_UBLAS_INLINE void swap (triangular_adaptor &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, const const_subiterator1_type &it1)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, const subiterator1_type &it1)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, const const_subiterator2_type &it2)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
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)
 
BOOST_UBLAS_INLINE permutation_matrix (size_type size)
 
BOOST_UBLAS_INLINE permutation_matrix (const vector_type &init)
 
BOOST_UBLAS_INLINE permutation_matrixoperator= (const permutation_matrix &m)
 
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)
 
BOOST_UBLAS_INLINE symmetric_matrix (size_type size)
 
BOOST_UBLAS_INLINE symmetric_matrix (size_type size1, size_type size2)
 
BOOST_UBLAS_INLINE symmetric_matrix (size_type size, const array_type &data)
 
BOOST_UBLAS_INLINE symmetric_matrix (const symmetric_matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrix (const matrix_expression< AE > &ae)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const array_type & data () const
 
BOOST_UBLAS_INLINE array_type & data ()
 
BOOST_UBLAS_INLINE void resize (size_type size, bool preserve=true)
 
BOOST_UBLAS_INLINE void resize (size_type size1, size_type size2, bool preserve=true)
 
BOOST_UBLAS_INLINE void resize_packed_preserve (size_type size)
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference at_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE reference insert_element (size_type i, size_type j, const_reference t)
 
BOOST_UBLAS_INLINE void erase_element (size_type i, size_type j)
 
BOOST_UBLAS_INLINE void clear ()
 
BOOST_UBLAS_INLINE symmetric_matrixoperator= (const symmetric_matrix &m)
 
BOOST_UBLAS_INLINE symmetric_matrixassign_temporary (symmetric_matrix &m)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrixoperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrixassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrixoperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrixplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrixoperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_matrixminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE symmetric_matrixoperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE symmetric_matrixoperator/= (const AT &at)
 
BOOST_UBLAS_INLINE void swap (symmetric_matrix &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, size_type it1, size_type it2)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
BOOST_UBLAS_INLINE symmetric_adaptor (matrix_type &data)
 
BOOST_UBLAS_INLINE symmetric_adaptor (const symmetric_adaptor &m)
 
BOOST_UBLAS_INLINE size_type size1 () const
 
BOOST_UBLAS_INLINE size_type size2 () const
 
BOOST_UBLAS_INLINE const matrix_closure_type & data () const
 
BOOST_UBLAS_INLINE matrix_closure_type & data ()
 
BOOST_UBLAS_INLINE const_reference operator() (size_type i, size_type j) const
 
BOOST_UBLAS_INLINE reference operator() (size_type i, size_type j)
 
BOOST_UBLAS_INLINE symmetric_adaptoroperator= (const symmetric_adaptor &m)
 
BOOST_UBLAS_INLINE symmetric_adaptorassign_temporary (symmetric_adaptor &m)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_adaptoroperator= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_adaptorassign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_adaptoroperator+= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_adaptorplus_assign (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_adaptoroperator-= (const matrix_expression< AE > &ae)
 
template<class AE >
BOOST_UBLAS_INLINE symmetric_adaptorminus_assign (const matrix_expression< AE > &ae)
 
template<class AT >
BOOST_UBLAS_INLINE symmetric_adaptoroperator*= (const AT &at)
 
template<class AT >
BOOST_UBLAS_INLINE symmetric_adaptoroperator/= (const AT &at)
 
BOOST_UBLAS_INLINE bool same_closure (const symmetric_adaptor &sa) const
 
BOOST_UBLAS_INLINE void swap (symmetric_adaptor &m)
 
BOOST_UBLAS_INLINE const_iterator1 find1 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator1 find1 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator2 find2 (int rank, size_type i, size_type j) const
 
BOOST_UBLAS_INLINE iterator2 find2 (int rank, size_type i, size_type j)
 
BOOST_UBLAS_INLINE const_iterator1 (const self_type &m, int begin, int end, const const_subiterator1_type &it1_begin, const const_subiterator1_type &it1_end, const const_subiterator2_type &it2_begin, const const_subiterator2_type &it2_end)
 
BOOST_UBLAS_INLINE const_iterator1 (const iterator1 &it)
 
BOOST_UBLAS_INLINE const_iterator1operator++ ()
 
BOOST_UBLAS_INLINE const_iterator1operator-- ()
 
BOOST_UBLAS_INLINE const_iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator2 begin () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator2 end () const
 
BOOST_UBLAS_INLINE const_iterator2 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator1operator= (const const_iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator1 &it) const
 
BOOST_UBLAS_INLINE const_iterator1 begin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin1 () const
 
BOOST_UBLAS_INLINE const_iterator1 end1 () const
 
BOOST_UBLAS_INLINE const_iterator1 cend1 () const
 
BOOST_UBLAS_INLINE iterator1 (self_type &m, const subiterator1_type &it1)
 
BOOST_UBLAS_INLINE iterator1operator++ ()
 
BOOST_UBLAS_INLINE iterator1operator-- ()
 
BOOST_UBLAS_INLINE iterator1operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator1operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator1 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator2 begin () const
 
BOOST_UBLAS_INLINE iterator2 end () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator1operator= (const iterator1 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator1 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator1 &it) const
 
BOOST_UBLAS_INLINE iterator1 begin1 ()
 
BOOST_UBLAS_INLINE iterator1 end1 ()
 
BOOST_UBLAS_INLINE const_iterator2 (const self_type &m, int begin, int end, const const_subiterator1_type &it1_begin, const const_subiterator1_type &it1_end, const const_subiterator2_type &it2_begin, const const_subiterator2_type &it2_end)
 
BOOST_UBLAS_INLINE const_iterator2 (const iterator2 &it)
 
BOOST_UBLAS_INLINE const_iterator2operator++ ()
 
BOOST_UBLAS_INLINE const_iterator2operator-- ()
 
BOOST_UBLAS_INLINE const_iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE const_iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_reference operator* () const
 
BOOST_UBLAS_INLINE const_reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE const_iterator1 begin () const
 
BOOST_UBLAS_INLINE const_iterator1 cbegin () const
 
BOOST_UBLAS_INLINE const_iterator1 end () const
 
BOOST_UBLAS_INLINE const_iterator1 cend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE const_iterator2operator= (const const_iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const const_iterator2 &it) const
 
BOOST_UBLAS_INLINE const_iterator2 begin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cbegin2 () const
 
BOOST_UBLAS_INLINE const_iterator2 end2 () const
 
BOOST_UBLAS_INLINE const_iterator2 cend2 () const
 
BOOST_UBLAS_INLINE iterator2 (self_type &m, const subiterator2_type &it2)
 
BOOST_UBLAS_INLINE iterator2operator++ ()
 
BOOST_UBLAS_INLINE iterator2operator-- ()
 
BOOST_UBLAS_INLINE iterator2operator+= (difference_type n)
 
BOOST_UBLAS_INLINE iterator2operator-= (difference_type n)
 
BOOST_UBLAS_INLINE difference_type operator- (const iterator2 &it) const
 
BOOST_UBLAS_INLINE reference operator* () const
 
BOOST_UBLAS_INLINE reference operator[] (difference_type n) const
 
BOOST_UBLAS_INLINE iterator1 begin () const
 
BOOST_UBLAS_INLINE iterator1 end () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rend () const
 
BOOST_UBLAS_INLINE size_type index1 () const
 
BOOST_UBLAS_INLINE size_type index2 () const
 
BOOST_UBLAS_INLINE iterator2operator= (const iterator2 &it)
 
BOOST_UBLAS_INLINE bool operator== (const iterator2 &it) const
 
BOOST_UBLAS_INLINE bool operator< (const iterator2 &it) const
 
BOOST_UBLAS_INLINE iterator2 begin2 ()
 
BOOST_UBLAS_INLINE iterator2 end2 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crbegin1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 rend1 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator1 crend1 () const
 
BOOST_UBLAS_INLINE reverse_iterator1 rbegin1 ()
 
BOOST_UBLAS_INLINE reverse_iterator1 rend1 ()
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crbegin2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 rend2 () const
 
BOOST_UBLAS_INLINE const_reverse_iterator2 crend2 () const
 
BOOST_UBLAS_INLINE reverse_iterator2 rbegin2 ()
 
BOOST_UBLAS_INLINE reverse_iterator2 rend2 ()
 
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...
 
 Matrix (int m, int n)
 
 Matrix (const MyMatrix &a)
 
 Matrix (const BoostMatrix &a)
 
 Matrix (int num_rows, const RowVector &v)
 
virtual unsigned int size () const
 Ask Number of Rows.
 
virtual unsigned int capacity () const
 Ask Number of Rows.
 
virtual unsigned int rows () const
 Ask Number of Rows.
 
virtual unsigned int columns () const
 Ask Number of Columns.
 
virtual double & operator() (unsigned int, unsigned int)
 Operator ()
 
virtual double operator() (unsigned int, unsigned int) const
 Operator ()
 
virtual RowVector operator[] (unsigned int) const
 
virtual bool operator== (const MyMatrix &a) const
 Operator ==.
 
virtual MyMatrix & operator= (double a)
 Set all elements of the Matrix equal to a.
 
virtual MyMatrix & operator+= (double a)
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator-= (double a)
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator*= (double b)
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator/= (double b)
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator+ (double b) const
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator- (double b) const
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator* (double b) const
 MATRIX - SCALAR operator.
 
virtual MyMatrix operator/ (double b) const
 MATRIX - SCALAR operator.
 
virtual MyMatrix & operator= (const MySymmetricMatrix &a)
 MATRIX - SYMMETRICMATRIX operators.
 
virtual MyMatrix & operator+= (const MyMatrix &a)
 MATRIX - MATRIX operator.
 
virtual MyMatrix & operator-= (const MyMatrix &a)
 MATRIX - MATRIX operator.
 
virtual MyMatrix operator+ (const MyMatrix &a) const
 MATRIX - MATRIX operator.
 
virtual MyMatrix operator- (const MyMatrix &a) const
 MATRIX - MATRIX operator.
 
virtual MyMatrix operator* (const MyMatrix &a) const
 MATRIX - MATRIX operator.
 
virtual MyColumnVector operator* (const MyColumnVector &b) const
 MATRIX - VECTOR operator.
 
virtual MyRowVector rowCopy (unsigned int r) const
 Get row from matrix.
 
virtual MyColumnVector columnCopy (unsigned int c) const
 Get column from matrix.
 
virtual void resize (unsigned int i, unsigned int j, bool copy=true, bool initialize=true)
 resize matrix
 
virtual MyMatrix inverse () const
 get inverse
 
virtual MyMatrix transpose () const
 get transpose
 
virtual double determinant () const
 get determinant
 
virtual int convertToSymmetricMatrix (MySymmetricMatrix &sym)
 Turn matrix into Symmetric one. More...
 
virtual MyMatrix sub (int i_start, int i_end, int j_start, int j_end) const
 get sub matrix
 
 SymmetricMatrix (int n)
 
 SymmetricMatrix (const MySymmetricMatrix &a)
 
 SymmetricMatrix (const BoostSymmetricMatrix &a)
 
 SymmetricMatrix (int num_rows, const RowVector &v)
 
virtual unsigned int size () const
 Ask Number of Rows.
 
virtual unsigned int capacity () const
 Ask Number of Rows.
 
virtual unsigned int rows () const
 Ask Number of Rows.
 
virtual unsigned int columns () const
 Ask Number of Columns.
 
virtual MySymmetricMatrix inverse () const
 get inverse
 
virtual MySymmetricMatrix transpose () const
 get transpose
 
virtual double determinant () const
 get determinant
 
virtual double & operator() (unsigned int, unsigned int)
 Operator ()
 
virtual double operator() (unsigned int, unsigned int) const
 Operator ()
 
virtual RowVector operator[] (unsigned int) const
 
virtual bool operator== (const MySymmetricMatrix &a) const
 Operator ==.
 
virtual MySymmetricMatrix & operator= (double a)
 Set all elements of the Matrix equal to a.
 
virtual MySymmetricMatrix & operator+= (double a)
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix & operator-= (double a)
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix & operator*= (double b)
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix & operator/= (double b)
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator+ (double b) const
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator- (double b) const
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator* (double b) const
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MySymmetricMatrix operator/ (double b) const
 SYMMETRICMATRIX - SCALAR operator.
 
virtual MyRowVector rowCopy (unsigned int r) const
 
virtual MyMatrix & operator+= (const MyMatrix &a)
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix & operator-= (const MyMatrix &a)
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix operator+ (const MyMatrix &a) const
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix operator- (const MyMatrix &a) const
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MyMatrix operator* (const MyMatrix &a) const
 SYMMETRICMATRIX - MATRIX operator.
 
virtual MySymmetricMatrix & operator+= (const MySymmetricMatrix &a)
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MySymmetricMatrix & operator-= (const MySymmetricMatrix &a)
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MySymmetricMatrix operator+ (const MySymmetricMatrix &a) const
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MySymmetricMatrix operator- (const MySymmetricMatrix &a) const
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MyMatrix operator* (const MySymmetricMatrix &a) const
 SYMMETRICMATRIX - SYMMETRICMATRIX operators.
 
virtual MyColumnVector operator* (const MyColumnVector &b) const
 SYMMETRICMATRIX - VECTOR operator.
 
virtual void multiply (const MyColumnVector &b, MyColumnVector &result) const
 SYMMETRICMATRIX - VECTOR operator.
 
virtual void resize (unsigned int i, bool copy=true, bool initialize=true)
 resize symmetric matrix
 
virtual MyMatrix sub (int i_start, int i_end, int j_start, int j_end) const
 get sub matrix
 
 ColumnVector ()
 Constructor.
 
 ColumnVector (int nrows)
 Constructor.
 
 ColumnVector (int nrows, double value)
 
 ColumnVector (const MyColumnVector &a, const MyColumnVector &b)
 Constructor.
 
virtual ~ColumnVector ()
 Destructor.
 
 ColumnVector (const MyColumnVector &a)
 Copy constructor.
 
 ColumnVector (const BoostColumnVector &a)
 Copy constructor.
 
virtual void resize (int num_rows)
 resize
 
virtual unsigned int rows () const
 Ask number of rows.
 
virtual unsigned int columns () const
 Ask numbers of columns (=1)
 
virtual unsigned int capacity () const
 capacity
 
virtual void assign (int size, double value)
 assign
 
virtual ColumnVector vectorAdd (const MyColumnVector &v2) const
 join two vectors
 
virtual ColumnVectoroperator= (const MyColumnVector &a)
 operator =
 
virtual ColumnVectoroperator= (double a)
 Initialise all elements to a.
 
virtual MyColumnVector & operator+= (const MyColumnVector &a)
 Operators.
 
virtual MyColumnVector & operator-= (const MyColumnVector &a)
 Operators.
 
virtual MyColumnVector operator+ (const MyColumnVector &a) const
 Operators.
 
virtual MyColumnVector operator- (const MyColumnVector &a) const
 Operators.
 
virtual MyColumnVector & operator+= (double b)
 Operators.
 
virtual MyColumnVector & operator-= (double b)
 Operators.
 
virtual MyColumnVector & operator*= (double b)
 Operators.
 
virtual MyColumnVector & operator/= (double b)
 Operators.
 
virtual MyColumnVector operator+ (double b) const
 Operators.
 
virtual MyColumnVector operator- (double b) const
 Operators.
 
virtual MyColumnVector operator* (double b) const
 Operators.
 
virtual MyColumnVector operator/ (double b) const
 Operators.
 
virtual double operator[] (unsigned int i) const
 element indexing STARTING FROM 0
 
virtual double & operator[] (unsigned int i)
 element indexing STARTING FROM 0
 
virtual double operator() (unsigned int) const
 element indexing
 
virtual bool operator== (const MyColumnVector &a) const
 Operator ==.
 
virtual double & operator() (unsigned int)
 element indexing
 
virtual MyMatrix operator* (const MyRowVector &a) const
 Operators.
 
virtual MyColumnVector sub (int j_start, int j_end) const
 get sub matrix
 
virtual MyRowVector transpose () const
 get transpose
 
 RowVector (int ncols)
 
 RowVector (int ncols, double value)
 
 RowVector (const MyRowVector &a)
 
 RowVector (const BoostRowVector &a)
 
virtual void resize (int num_cols)
 resize
 
virtual void assign (int size, double value)
 assign
 
virtual RowVector vectorAdd (const MyRowVector &v2) const
 join two vectors
 
virtual unsigned int rows () const
 Ask number of rows.
 
virtual unsigned int columns () const
 Ask numbers of columns (=1)
 
virtual unsigned int capacity () const
 Ask numbers of capacity.
 
virtual RowVectoroperator= (double a)
 Initialise all elements to a.
 
virtual RowVectoroperator= (const MyRowVector &a)
 operator =
 
virtual MyRowVector & operator+= (const MyRowVector &a)
 Operators.
 
virtual MyRowVector & operator-= (const MyRowVector &a)
 Operators.
 
virtual MyRowVector operator+ (const MyRowVector &a) const
 Operators.
 
virtual MyRowVector operator- (const MyRowVector &a) const
 Operators.
 
virtual MyRowVector & operator+= (double b)
 Operators.
 
virtual MyRowVector & operator-= (double b)
 Operators.
 
virtual MyRowVector & operator*= (double b)
 Operators.
 
virtual MyRowVector & operator/= (double b)
 Operators.
 
virtual MyRowVector operator+ (double b) const
 Operators.
 
virtual MyRowVector operator- (double b) const
 Operators.
 
virtual MyRowVector operator* (double b) const
 Operators.
 
virtual MyRowVector operator/ (double b) const
 Operators.
 
virtual double operator() (unsigned int) const
 element indexing
 
virtual bool operator== (const MyRowVector &a) const
 Operator ==.
 
virtual double & operator() (unsigned int)
 element indexing
 
virtual MyRowVector sub (int j_start, int j_end) const
 get sub matrix
 
virtual MyColumnVector transpose () const
 get transpose
 
virtual double operator* (const MyColumnVector &a) const
 Operators.
 
 Sample (unsigned int dimension=0)
 Constructor. More...
 
virtual ~Sample ()
 Destructor.
 
 Sample (const Sample< T > &my_sample)
 Copy Constructor.
 
T & ValueGet ()
 Get the value of the Sample.
 
const T & ValueGet () const
 Get the value of the Sample.
 
unsigned int DimensionGet () const
 
void DimensionSet (unsigned int dim)
 
void ValueSet (const T &value)
 Set the value of the Sample. More...
 
Sampleoperator= (const Sample &my_sample)
 Operator =.
 
template<typename S >
ostream & operator<< (ostream &stream, Sample< S > &my_sample)
 
template<typename S >
istream & operator>> (istream &stream, Sample< S > &my_sample)
 
 WeightedSample (int dimension=0)
 Constructor. More...
 
virtual ~WeightedSample ()
 Destructor.
 
 WeightedSample (const WeightedSample< T > &my_weighted_sample)
 Copy constructor.
 
double WeightGet () const
 Get the weight. More...
 
void WeightSet (double weight)
 Set the weight. More...
 
WeightedSample< T > & operator= (const WeightedSample< T > &my_sample)
 Operator =.
 
WeightedSample< T > & operator= (const Sample< T > &my_sample)
 Turn sample into weighted one (weight = 1)
 
template<typename S >
ostream & operator<< (ostream &stream, WeightedSample< S > &mws)
 
 Sample (const Sample< T > &my_sample)
 Copy Constructor.
 

Variables

int __count
 
__WINT_TYPE__   __wch
 
char   __wchb [4]
 
union {
   __WINT_TYPE__   __wch
 
   char   __wchb [4]
 
__value
 
struct __locale_data * __locales [13]
 
const unsigned short int * __ctype_b
 
const int * __ctype_tolower
 
const int * __ctype_toupper
 
const char * __names [13]
 
_Compare _M_comp
 
_Compare _M_comp
 
_Compare _M_comp
 
_Value & _M_value
 
_Iterator1 _M_it1
 
_Predicate _M_pred
 
_Compare _M_comp
 
_Value & _M_value
 
_Compare _M_comp
 
_Iterator1 _M_it1
 
_Predicate _M_pred
 
char * decimal_point
 
char * thousands_sep
 
char * grouping
 
char * int_curr_symbol
 
char * currency_symbol
 
char * mon_decimal_point
 
char * mon_thousands_sep
 
char * mon_grouping
 
char * positive_sign
 
char * negative_sign
 
char int_frac_digits
 
char frac_digits
 
char p_cs_precedes
 
char p_sep_by_space
 
char n_cs_precedes
 
char n_sep_by_space
 
char p_sign_posn
 
char n_sign_posn
 
char int_p_cs_precedes
 
char int_p_sep_by_space
 
char int_n_cs_precedes
 
char int_n_sep_by_space
 
char int_p_sign_posn
 
char int_n_sign_posn
 
__time_t tv_sec
 
__syscall_slong_t tv_nsec
 
int sched_priority
 
__cpu_mask __bits [__CPU_SETSIZE/__NCPUBITS]
 
int tm_sec
 
int tm_min
 
int tm_hour
 
int tm_mday
 
int tm_mon
 
int tm_year
 
int tm_wday
 
int tm_yday
 
int tm_isdst
 
long int tm_gmtoff
 
const char * tm_zone
 
struct timespec it_interval
 
struct timespec it_value
 
unsigned int __readers
 
unsigned int __writers
 
unsigned int __wrphase_futex
 
unsigned int __writers_futex
 
unsigned int __pad3
 
unsigned int __pad4
 
unsigned char __flags
 
unsigned char __shared
 
signed char __rwelision
 
unsigned char __pad2
 
int __cur_writer
 
struct __pthread_internal_slist__next
 
int __lock __LOCK_ALIGNMENT
 
unsigned int __count
 
int __owner
 
int __kind
 
__PTHREAD_COMPAT_PADDING_MID unsigned int __nusers
 
   __PTHREAD_SPINS_DATA
 
__pthread_slist_t   __list
 
union {
      __PTHREAD_SPINS_DATA
 
   __pthread_slist_t   __list
 
}; 
 
__extension__ unsigned long long int   __wseq
 
unsigned int   __low
 
unsigned int   __high
 
struct {
   unsigned int   __low
 
   unsigned int   __high
 
}   __wseq32
 
union {
   __extension__ unsigned long long int   __wseq
 
   struct {
      unsigned int   __low
 
      unsigned int   __high
 
   }   __wseq32
 
}; 
 
__extension__ unsigned long long int   __g1_start
 
unsigned int   __low
 
unsigned int   __high
 
struct {
   unsigned int   __low
 
   unsigned int   __high
 
}   __g1_start32
 
union {
   __extension__ unsigned long long int   __g1_start
 
   struct {
      unsigned int   __low
 
      unsigned int   __high
 
   }   __g1_start32
 
}; 
 
unsigned int __g_refs [2] __LOCK_ALIGNMENT
 
unsigned int __g_size [2]
 
unsigned int __g1_orig_size
 
unsigned int __wrefs
 
unsigned int __g_signals [2]
 
char __size [__SIZEOF_PTHREAD_MUTEXATTR_T]
 
int __align
 
char __size [__SIZEOF_PTHREAD_CONDATTR_T]
 
int __align
 
char __size [__SIZEOF_PTHREAD_ATTR_T]
 
long int __align
 
struct __pthread_mutex_s __data
 
char __size [__SIZEOF_PTHREAD_MUTEX_T]
 
long int __align
 
struct __pthread_cond_s __data
 
char __size [__SIZEOF_PTHREAD_COND_T]
 
__extension__ long long int __align
 
struct __pthread_rwlock_arch_t __data
 
char __size [__SIZEOF_PTHREAD_RWLOCK_T]
 
long int __align
 
char __size [__SIZEOF_PTHREAD_RWLOCKATTR_T]
 
long int __align
 
char __size [__SIZEOF_PTHREAD_BARRIER_T]
 
long int __align
 
char __size [__SIZEOF_PTHREAD_BARRIERATTR_T]
 
int __align
 
void(* __routine )(void *)
 
void * __arg
 
int __canceltype
 
struct _pthread_cleanup_buffer__prev
 
__jmp_buf   __cancel_jmp_buf
 
int   __mask_was_saved
 
struct {
   __jmp_buf   __cancel_jmp_buf
 
   int   __mask_was_saved
 
__cancel_jmp_buf [1]
 
void * __pad [4]
 
void(* __cancel_routine )(void *)
 
void * __cancel_arg
 
int __do_it
 
int __cancel_type
 
const nothrow_t nothrow
 
static const T value = val
 
static const bool value = val
 
char padding [8]
 
static const bool value = (A::value || B::value || C::value)
 
static const bool value = is_void<To>::value
 
static const bool value = sizeof(test<From, To>(0)) == 1
 
static const bool value = ::boost::is_convertible<typename boost::add_reference<T>::type, ::boost::detail::int_convertible>::value
 
char padding [256]
 
char padding [256]
 
static constexpr bool value = false
 
static constexpr bool value = true
 
static constexpr bool value = false
 
static constexpr bool value = true
 
static constexpr bool value = false
 
static constexpr bool value = true
 
static constexpr bool value
 
static const bool value = false
 
static const bool value = noexcept(boost::declval<typename add_reference<T>::type>() = boost::declval<typename add_reference<T const>::type>())
 
static const bool value = has_nothrow_assign_imp<T, false, true>::value
 
static const bool value = has_nothrow_assign_imp<T, false, true>::value
 
static assert_ const arg
 
char c
 
t
 
char c
 
short s
 
int i
 
long l
 
float f
 
double d
 
long double ld
 
char buf [size_]
 
typename ::boost::type_with_alignment< alignment_ >::type align_
 
union BFL::boost::detail::aligned_storage::aligned_storage_imp::data_t data_
 
char buf [size]
 
::boost::detail::max_align align_
 
union BFL::boost::detail::aligned_storage::aligned_storage_imp< size, std::size_t(-1)>::data_t data_
 
template<class U >
static decltype(::boost::declval< U & >()=::boost::declval< const U & >(), yes_type()) test (int)
 
static const bool value = sizeof(test<T>(0)) == sizeof(yes_type)
 
int i [256]
 
int i [256]
 
static const no_cv_t minus_one = (static_cast<no_cv_t>(-1))
 
static const no_cv_t zero = (static_cast<no_cv_t>(0))
 
static const no_cv_t minus_one = (static_cast<no_cv_t>(-1))
 
static const no_cv_t zero = (static_cast<no_cv_t>(0))
 
unsigned u
 
unsigned long ul
 
void * v
 
double d
 
long double ld
 
max_align data [16]
 
max_align data [16]
 
static T testee
 
static base_type::x_type x
 
static base_type::y_type y
 
static const std::size_t size
 
static const std::size_t index = (size / sizeof (char)) - 1
 
static const unsigned plus_complexity = 1
 
static const unsigned multiplies_complexity = 1
 
static const unsigned multiplies_complexity = 1
 
static const unsigned plus_complexity = 2
 
static const unsigned multiplies_complexity = 6
 
static const bool computed = false
 
static const bool computed = true
 
static const bool computed = true
 
static const bool computed = true
 
static const bool computed = true
 
static const unsigned complexity = 0
 
static const unsigned complexity = 0
 
static const unsigned complexity = 0
 
static const unsigned complexity = 0
 
static const unsigned complexity = 1
 
static const size_type max_size = N
 
static const unsigned complexity = 1
 
static const unsigned complexity = 1
 
static const unsigned complexity = 1
 
static const size_type max_size1 = M
 
static const size_type max_size2 = N
 
Value
 The Sample Value.
 
double Weight
 The weight.
 

Friends

template<class Archive , class T >
struct detail::member_saver
 
template<class Archive , class T >
struct detail::member_loader
 
template<class Archive , class T >
class archive::detail::iserializer
 
template<class Archive , class T >
class archive::detail::oserializer
 
class indexed_iterator< container_type, iterator_category >
 
class indexed_iterator1< container_type, iterator_category >
 
class indexed_iterator2< container_type, iterator_category >
 
class boost::serialization::access
 
class boost::serialization::access
 
class index_pair< self_type >
 
class index_triple< self_type >
 
class iterator
 
class const_iterator
 
class iterator
 
class const_iterator
 
class iterator1
 
class const_iterator1
 
class iterator2
 
class const_iterator2
 
class iterator1
 
class const_iterator1
 
class iterator2
 
class const_iterator2
 
class iterator1
 
class const_iterator1
 
class iterator2
 
class const_iterator2
 
class const_iterator
 
class const_iterator
 
class const_iterator
 
class const_iterator
 
class const_iterator
 
class const_iterator1
 
class const_iterator2
 
class const_iterator1
 
class const_iterator2
 
class const_iterator1
 
class const_iterator2
 
class const_iterator
 
class const_iterator
 
class const_iterator
 
class const_iterator1
 
class const_iterator2
 
class const_iterator1
 
class const_iterator2
 
class const_iterator1
 
class const_iterator2
 
class const_iterator1
 
class const_iterator2
 
ostream & operator<< (ostream &stream, Probability &prob)
 
istream & operator>> (istream &stream, Probability &prob)
 
template<class Archive , class T >
void serialize (Archive &ar, T &t, const unsigned int file_version)
 
template<class Archive , class T >
void save_construct_data (Archive &ar, const T *t, const unsigned int file_version)
 
template<class Archive , class T >
void load_construct_data (Archive &ar, T *t, const unsigned int file_version)
 
bool operator<= (const T &x, const U &y)
 
bool operator>= (const T &x, const U &y)
 
bool operator> (const U &x, const T &y)
 
bool operator< (const U &x, const T &y)
 
bool operator<= (const U &x, const T &y)
 
bool operator>= (const U &x, const T &y)
 
bool operator> (const T &x, const T &y)
 
bool operator<= (const T &x, const T &y)
 
bool operator>= (const T &x, const T &y)
 
bool operator== (const U &y, const T &x)
 
bool operator!= (const U &y, const T &x)
 
bool operator!= (const T &y, const U &x)
 
bool operator!= (const T &x, const T &y)
 
operator++ (T &x, int)
 
operator-- (T &x, int)
 
bool operator== (const T &x, const U &y)
 
bool operator== (const T &x, const T &y)
 
bool operator<= (const T &x, const U &y)
 
bool operator>= (const T &x, const U &y)
 
bool operator> (const U &x, const T &y)
 
bool operator< (const U &x, const T &y)
 
bool operator<= (const U &x, const T &y)
 
bool operator>= (const U &x, const T &y)
 
bool operator> (const T &x, const T &y)
 
bool operator<= (const T &x, const T &y)
 
bool operator>= (const T &x, const T &y)
 
requires_difference_operator (const T &x, const T &y)
 
template<class Tx , class S >
const boost::serialization::array_wrapper< Tx > make_array (Tx *t, S s)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator++ (derived_iterator_type &d, int)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator++ (derived_iterator_type &d, int)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator-- (derived_iterator_type &d, int)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator++ (derived_iterator_type &d, int)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator-- (derived_iterator_type &d, int)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator+ (const derived_iterator_type &d, derived_difference_type n)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator+ (derived_difference_type n, const derived_iterator_type &d)
 
BOOST_UBLAS_INLINE friend derived_iterator_type operator- (const derived_iterator_type &d, derived_difference_type n)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base operator+ (const reverse_iterator_base &it, difference_type n)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base operator+ (difference_type n, const reverse_iterator_base &it)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base operator- (const reverse_iterator_base &it, difference_type n)
 
BOOST_UBLAS_INLINE friend difference_type operator- (const reverse_iterator_base &it1, const reverse_iterator_base &it2)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base1 operator+ (const reverse_iterator_base1 &it, difference_type n)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base1 operator+ (difference_type n, const reverse_iterator_base1 &it)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base1 operator- (const reverse_iterator_base1 &it, difference_type n)
 
BOOST_UBLAS_INLINE friend difference_type operator- (const reverse_iterator_base1 &it1, const reverse_iterator_base1 &it2)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base2 operator+ (const reverse_iterator_base2 &it, difference_type n)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base2 operator+ (difference_type n, const reverse_iterator_base2 &it)
 
BOOST_UBLAS_INLINE friend reverse_iterator_base2 operator- (const reverse_iterator_base2 &it, difference_type n)
 
BOOST_UBLAS_INLINE friend difference_type operator- (const reverse_iterator_base2 &it1, const reverse_iterator_base2 &it2)
 
BOOST_UBLAS_INLINE friend void swap (unbounded_array &a1, unbounded_array &a2)
 
BOOST_UBLAS_INLINE friend void swap (bounded_array &a1, bounded_array &a2)
 
BOOST_UBLAS_INLINE friend void swap (array_adaptor &a1, array_adaptor &a2)
 
BOOST_UBLAS_INLINE friend void swap (self_type &lhs, self_type &rhs)
 
void swap (self_type lhs, self_type rhs)
 
BOOST_UBLAS_INLINE friend bool operator== (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator!= (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator< (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator>= (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator> (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator<= (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend void iter_swap (const iterator &lhs, const iterator &rhs)
 
BOOST_UBLAS_INLINE friend void swap (self_type &lhs, self_type &rhs)
 
void swap (self_type lhs, self_type rhs)
 
BOOST_UBLAS_INLINE friend bool operator== (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator!= (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator< (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator>= (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator> (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend bool operator<= (const self_type &lhs, const self_type &rhs)
 
BOOST_UBLAS_INLINE friend void iter_swap (const iterator &lhs, const iterator &rhs)
 
BOOST_UBLAS_INLINE friend void swap (vector &v1, vector &v2)
 Swap the content of two vectors. More...
 
BOOST_UBLAS_INLINE friend void swap (zero_vector &v1, zero_vector &v2)
 
BOOST_UBLAS_INLINE friend void swap (unit_vector &v1, unit_vector &v2)
 
BOOST_UBLAS_INLINE friend void swap (scalar_vector &v1, scalar_vector &v2)
 
BOOST_UBLAS_INLINE friend void swap (c_vector &v1, c_vector &v2)
 
BOOST_UBLAS_INLINE friend void swap (matrix &m1, matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (vector_of_vector &m1, vector_of_vector &m2)
 
BOOST_UBLAS_INLINE friend void swap (zero_matrix &m1, zero_matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (identity_matrix &m1, identity_matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (scalar_matrix &m1, scalar_matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (c_matrix &m1, c_matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_row mr1, matrix_row mr2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_column mc1, matrix_column mc2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_vector_range mvr1, matrix_vector_range mvr2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_vector_slice mvs1, matrix_vector_slice mvs2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_vector_indirect mvi1, matrix_vector_indirect mvi2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_range mr1, matrix_range mr2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_slice ms1, matrix_slice ms2)
 
BOOST_UBLAS_INLINE friend void swap (matrix_indirect mi1, matrix_indirect mi2)
 
BOOST_UBLAS_INLINE friend void swap (vector_range vr1, vector_range vr2)
 
BOOST_UBLAS_INLINE friend void swap (vector_slice vs1, vector_slice vs2)
 
BOOST_UBLAS_INLINE friend void swap (vector_indirect vi1, vector_indirect vi2)
 
BOOST_UBLAS_INLINE friend void swap (triangular_matrix &m1, triangular_matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (triangular_adaptor &m1, triangular_adaptor &m2)
 
BOOST_UBLAS_INLINE friend void swap (symmetric_matrix &m1, symmetric_matrix &m2)
 
BOOST_UBLAS_INLINE friend void swap (symmetric_adaptor &m1, symmetric_adaptor &m2)
 
template<typename S >
ostream & operator<< (ostream &stream, Sample< S > &my_sample)
 Print a sample. More...
 
template<typename S >
istream & operator>> (istream &stream, Sample< S > &my_sample)
 
template<typename S >
ostream & operator<< (ostream &stream, WeightedSample< S > &mws)
 Print a weighted sample. More...
 

Standard Stream Objects

typedef boost::numeric::ublas::matrix< double > BoostMatrix
 
typedef boost::numeric::ublas::symmetric_matrix< double, boost::numeric::ublas::lowerBoostSymmetricMatrix
 
static bool value = false
 
virtual void UpdateInternal (SystemModel< StateVar > *const sysmodel, const StateVar &u, MeasurementModel< MeasVar, StateVar > *const measmodel, const MeasVar &z, const StateVar &s)
 Actual implementation of updateinternal.
 
 ASIRFilter (MCPdf< StateVar > *prior, int resampleperiod=0, double resamplethreshold=0, int resamplescheme=DEFAULT_RS)
 Constructor. More...
 
virtual ~ASIRFilter ()
 Destructor.
 
__BEGIN_DECLS void __assert_fail (const char *__assertion, const char *__file, unsigned int __line, const char *__function) __THROW __attribute__((__noreturn__))
 
void __assert_perror_fail (int __errnum, const char *__file, unsigned int __line, const char *__function) __THROW __attribute__((__noreturn__))
 
void __assert (const char *__assertion, const char *__file, int __line) __THROW __attribute__((__noreturn__))
 
#define BOOST_CONFIG_CMATH
 
#define BOOST_TR1_NO_RECURSION
 
#define BOOST_CONFIG_NO_CMATH_RECURSION
 
#define _BOOST_UBLAS_ITERATOR_
 
#define _BOOST_UBLAS_NUMERICTYPE_DEDUCTION_
 
#define BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED
 
#define BOOST_MPL_AT_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED
 
#define BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED
 
#define BOOST_MPL_LONG_HPP_INCLUDED
 
#define BOOST_MPL_LONG_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_FRONT_HPP_INCLUDED
 
#define BOOST_MPL_FRONT_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED
 
#define BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED
 
#define BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED
 
#define BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED
 
#define BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED
 
#define BOOST_MPL_BACK_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED
 
#define BOOST_MPL_CLEAR_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED
 
#define BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED
 
#define BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED
 
#define BOOST_MPL_PLUS_HPP_INCLUDED
 
#define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED
 
#define BOOST_MPL_MINUS_HPP_INCLUDED
 
#define BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
 
#define BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED
 
#define BOOST_MPL_PRIOR_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED
 
#define BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED
 
#define BOOST_MPL_SIZE_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED
 
#define BOOST_MPL_EMPTY_FWD_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED
 
#define BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED
 
#define BOOST_MPL_AT_HPP_INCLUDED
 
#define BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED
 
#define BOOST_MPL_BEGIN_END_HPP_INCLUDED
 
#define BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED
 
#define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED
 
#define BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED
 
#define BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED
 
#define BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED
 
#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(i, trait)
 
#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait)
 
#define BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED
 
#define BOOST_MPL_ADVANCE_HPP_INCLUDED
 
#define BOOST_MPL_LESS_HPP_INCLUDED
 
#define BOOST_MPL_NEGATE_HPP_INCLUDED
 
#define BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED
 
#define BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED
 
#define BOOST_MPL_DEREF_HPP_INCLUDED
 
#define BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED
 
#define BOOST_MPL_OR_HPP_INCLUDED
 
#define BOOST_UTILITY_ENABLE_IF_HPP
 
#define BOOST_CORE_ENABLE_IF_HPP
 
#define BOOST_TYPE_TRAITS_HPP
 
#define BOOST_TT_ADD_CONST_HPP_INCLUDED
 
#define BOOST_TT_ADD_CV_HPP_INCLUDED
 
#define BOOST_TT_ADD_POINTER_HPP_INCLUDED
 
#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
 
#define BOOST_TT_ALIGNED_STORAGE_HPP
 
#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
 
#define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED
 
#define BOOST_TT_CONDITIONAL_HPP_INCLUDED
 
#define BOOST_TYPE_TRAITS_COMMON_TYPE_HPP_INCLUDED
 
#define BOOST_TT_DECAY_HPP_INCLUDED
 
#define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
 
#define BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED
 
#define BOOST_TYPE_TRAITS_DETAIL_MP_DEFER_HPP_INCLUDED
 
#define BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED
 
#define BOOST_TT_EXTENT_HPP_INCLUDED
 
#define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
 
#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 
#define BOOST_TT_HAS_BIT_AND_HPP_INCLUDED
 
#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED
 
#define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED
 
#define BOOST_TT_HAS_BIT_AND_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_BIT_OR_HPP_INCLUDED
 
#define BOOST_TT_HAS_BIT_OR_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_BIT_XOR_HPP_INCLUDED
 
#define BOOST_TT_HAS_BIT_XOR_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_COMPLEMENT_HPP_INCLUDED
 
#define BOOST_TT_HAS_DEREFERENCE_HPP_INCLUDED
 
#define BOOST_TT_HAS_DIVIDES_HPP_INCLUDED
 
#define BOOST_TT_HAS_DIVIDES_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_EQUAL_TO_HPP_INCLUDED
 
#define BOOST_TT_HAS_GREATER_HPP_INCLUDED
 
#define BOOST_TT_HAS_GREATER_EQUAL_HPP_INCLUDED
 
#define BOOST_TT_HAS_LEFT_SHIFT_HPP_INCLUDED
 
#define BOOST_TT_HAS_LEFT_SHIFT_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_LESS_HPP_INCLUDED
 
#define BOOST_TT_HAS_LESS_EQUAL_HPP_INCLUDED
 
#define BOOST_TT_HAS_LOGICAL_AND_HPP_INCLUDED
 
#define BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED
 
#define BOOST_TT_HAS_LOGICAL_OR_HPP_INCLUDED
 
#define BOOST_TT_HAS_MINUS_HPP_INCLUDED
 
#define BOOST_TT_HAS_MINUS_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_MODULUS_HPP_INCLUDED
 
#define BOOST_TT_HAS_MODULUS_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_MULTIPLIES_HPP_INCLUDED
 
#define BOOST_TT_HAS_MULTIPLIES_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_NEGATE_HPP_INCLUDED
 
#define BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
 
#define BOOST_TT_HAS_NOT_EQUAL_TO_HPP_INCLUDED
 
#define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
 
#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED
 
#define BOOST_TT_HAS_PLUS_HPP_INCLUDED
 
#define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED
 
#define BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED
 
#define BOOST_TT_HAS_PRE_DECREMENT_HPP_INCLUDED
 
#define BOOST_TT_HAS_PRE_INCREMENT_HPP_INCLUDED
 
#define BOOST_TT_HAS_RIGHT_SHIFT_HPP_INCLUDED
 
#define BOOST_TT_HAS_RIGHT_SHIFT_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED
 
#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
 
#define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
 
#define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
 
#define BOOST_TT_HAS_UNARY_MINUS_HPP_INCLUDED
 
#define BOOST_TT_HAS_UNARY_PLUS_HPP_INCLUDED
 
#define BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED
 
#define BOOST_TT_IS_COMPLEX_HPP
 
#define BOOST_TT_IS_COMPOUND_HPP_INCLUDED
 
#define BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
 
#define BOOST_TT_CXX11_IS_COPY_ASSIGNABLE
 
#define BOOST_TT_IS_EMPTY_HPP_INCLUDED
 
#define BOOST_INTERNAL_IS_EMPTY(T)   false
 
#define BOOST_TT_IS_FINAL_HPP_INCLUDED
 
#define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED
 
#define BOOST_TT_IS_MEMBER_OBJECT_POINTER_HPP_INCLUDED
 
#define BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED
 
#define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
 
#define BOOST_TT_IS_OBJECT_HPP_INCLUDED
 
#define BOOST_TT_IS_SIGNED_HPP_INCLUDED
 
#define _GCC_LIMITS_H_
 
#define _GCC_NEXT_LIMITS_H   /* tell gcc's limits.h to recurse */
 
#define _LIMITS_H___
 
#define CHAR_BIT   __CHAR_BIT__
 
#define SCHAR_MIN   (-SCHAR_MAX - 1)
 
#define SCHAR_MAX   __SCHAR_MAX__
 
#define UCHAR_MAX   (SCHAR_MAX * 2U + 1U)
 
#define CHAR_MIN   SCHAR_MIN
 
#define CHAR_MAX   SCHAR_MAX
 
#define SHRT_MIN   (-SHRT_MAX - 1)
 
#define SHRT_MAX   __SHRT_MAX__
 
#define USHRT_MAX   (SHRT_MAX * 2U + 1U)
 
#define INT_MIN   (-INT_MAX - 1)
 
#define INT_MAX   __INT_MAX__
 
#define UINT_MAX   (INT_MAX * 2U + 1U)
 
#define LONG_MIN   (-LONG_MAX - 1L)
 
#define LONG_MAX   __LONG_MAX__
 
#define ULONG_MAX   (LONG_MAX * 2UL + 1UL)
 
#define _GLIBCXX_CLIMITS   1
 
#define BOOST_TT_IS_STATELESS_HPP_INCLUDED
 
#define BOOST_TT_IS_UNSIGNED_HPP_INCLUDED
 
#define BOOST_TT_IS_VIRTUAL_BASE_OF_HPP_INCLUDED
 
#define BOOST_TT_MAKE_SIGNED_HPP_INCLUDED
 
#define BOOST_TT_MAKE_UNSIGNED_HPP_INCLUDED
 
#define BOOST_TT_MAKE_VOID_HPP_INCLUDED
 
#define BOOST_TT_RANK_HPP_INCLUDED
 
#define BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
 
#define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED
 
#define BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED
 
#define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
 
#define FILE_boost_type_traits_promote_hpp_INCLUDED
 
#define BOOST_TYPEOF_TYPEOF_HPP_INCLUDED
 
#define BOOST_TYPEOF_DECLTYPE
 
#define BOOST_TYPEOF_UNIQUE_ID()   BOOST_TYPEOF_REGISTRATION_GROUP * 0x10000 + __LINE__
 
#define BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()   <boost/typeof/incr_registration_group.hpp>
 
#define BOOST_TYPEOF_TEXT   "using native typeof"
 
#define BOOST_TYPEOF_DECLTYPE_HPP_INCLUDED
 
#define BOOST_TYPEOF(expr)   boost::type_of::remove_cv_ref_t<decltype(expr)>
 
#define BOOST_TYPEOF_TPL   BOOST_TYPEOF
 
#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name, expr)
 
#define BOOST_TYPEOF_NESTED_TYPEDEF(name, expr)
 
#define BOOST_TYPEOF_REGISTER_TYPE(x)
 
#define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
 
#define BOOST_AUTO(Var, Expr)   BOOST_TYPEOF(Expr) Var = Expr
 
#define BOOST_AUTO_TPL(Var, Expr)   BOOST_TYPEOF_TPL(Expr) Var = Expr
 
#define _BOOST_UBLAS_VECTOR_EXPRESSION_
 
#define _BOOST_UBLAS_EXPRESSION_TYPE_
 
#define _BOOST_UBLAS_FUNCTIONAL_
 
#define _GLIBCXX_FUNCTIONAL   1
 
#define BOOST_CORE_IGNORE_UNUSED_HPP
 
#define _BOOST_UBLAS_VECTOR_ASSIGN_
 
#define _GLIBCXX_VECTOR   1
 
#define _STL_VECTOR_H   1
 
#define _STL_BVECTOR_H   1
 
#define _VECTOR_TCC   1
 
#define _BOOST_UBLAS_MATRIX_EXPRESSION_
 
#define _BOOST_UBLAS_MATRIX_ASSIGN_
 
#define _BOOST_UBLAS_LU_
 
#define _BOOST_UBLAS_OPERATION_
 
#define _BOOST_UBLAS_MATRIX_PROXY_
 
#define _BOOST_UBLAS_TEMPORARY_
 
#define _BOOST_UBLAS_VECTOR_PROXY_
 
#define _BOOST_UBLAS_TRIANGULAR_
 
#define _BOOST_UBLAS_SYMMETRIC_
 
#define _BOOST_UBLAS_IO_
 
#define BoostColumnVector   boost::numeric::ublas::vector<double>
 
#define BoostRowVector   boost::numeric::ublas::vector<double>
 

Detailed Description

Classes and functions for complex numbers.

Macro Definition Documentation

◆ AUX778076_IMPL_SPEC

#define AUX778076_IMPL_SPEC (   name,
  tag,
  result 
)
Value:
template<> \
struct name##_impl<tag> \
{ \
template< typename Sequence > struct apply \
{ \
typedef result type; \
}; \
}; \

Definition at line 70 of file asirfilter.h.

◆ AUX_CLASS_SEQUENCE_TAG_SPEC

#define AUX_CLASS_SEQUENCE_TAG_SPEC (   has_tag,
  has_begin,
  result_type 
)
Value:
template<> struct sequence_tag_impl<has_tag,has_begin> \
{ \
template< typename Sequence > struct result2_ \
{ \
typedef result_type type; \
}; \
}; \

Definition at line 88 of file asirfilter.h.

◆ BOOST_BINARY_OPERATOR

#define BOOST_BINARY_OPERATOR (   NAME,
  OP 
)
Value:
template <class T, class U, class B = operators_detail::empty_base<T> > \
struct NAME##2 : B \
{ \
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
}; \
\
template <class T, class B = operators_detail::empty_base<T> > \
struct NAME##1 : B \
{ \
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
};

Definition at line 342 of file asirfilter.h.

◆ BOOST_BINARY_OPERATOR_COMMUTATIVE

#define BOOST_BINARY_OPERATOR_COMMUTATIVE (   NAME,
  OP 
)
Value:
template <class T, class U, class B = operators_detail::empty_base<T> > \
struct NAME##2 : B \
{ \
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
}; \
\
template <class T, class B = operators_detail::empty_base<T> > \
struct NAME##1 : B \
{ \
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
};

Definition at line 223 of file asirfilter.h.

◆ BOOST_BINARY_OPERATOR_NON_COMMUTATIVE

#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE (   NAME,
  OP 
)
Value:
template <class T, class U, class B = operators_detail::empty_base<T> > \
struct NAME##2 : B \
{ \
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
}; \
\
template <class T, class U, class B = operators_detail::empty_base<T> > \
struct BOOST_OPERATOR2_LEFT(NAME) : B \
{ \
friend T operator OP( const U& lhs, const T& rhs ) \
{ return T( lhs ) OP##= rhs; } \
}; \
\
template <class T, class B = operators_detail::empty_base<T> > \
struct NAME##1 : B \
{ \
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
};

Definition at line 237 of file asirfilter.h.

◆ BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC

#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC (   i,
  trait 
)
Value:
BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(i, trait) \
template<> struct trait<non_sequence_tag> {}; \

Definition at line 58 of file asirfilter.h.

◆ BOOST_OPERATOR_TEMPLATE

#define BOOST_OPERATOR_TEMPLATE (   template_name)
Value:
template <class T \
,class U = T \
,class B = operators_detail::empty_base<T> \
,class O = typename is_chained_base<U>::value \
> \
struct template_name; \
\
template<class T, class U, class B> \
struct template_name<T, U, B, operators_detail::false_t> \
: template_name##2<T, U, B> {}; \
\
template<class T, class U> \
struct template_name<T, U, operators_detail::empty_base<T>, operators_detail::true_t> \
: template_name##1<T, U> {}; \
\
template <class T, class B> \
struct template_name<T, T, B, operators_detail::false_t> \
: template_name##1<T, B> {}; \
\
template<class T, class U, class B, class O> \
struct is_chained_base< template_name<T, U, B, O> > { \
typedef operators_detail::true_t value; \
}; \
\
BOOST_OPERATOR_TEMPLATE2(template_name##2) \
BOOST_OPERATOR_TEMPLATE1(template_name##1)

Definition at line 729 of file asirfilter.h.

◆ BOOST_OPERATOR_TEMPLATE1

#define BOOST_OPERATOR_TEMPLATE1 (   template_name1)
Value:
template<class T, class B> \
struct is_chained_base< template_name1<T, B> > { \
typedef operators_detail::true_t value; \
};

Definition at line 709 of file asirfilter.h.

◆ BOOST_OPERATOR_TEMPLATE2

#define BOOST_OPERATOR_TEMPLATE2 (   template_name2)
Value:
template<class T, class U, class B> \
struct is_chained_base< template_name2<T, U, B> > { \
typedef operators_detail::true_t value; \
};

Definition at line 701 of file asirfilter.h.

◆ BOOST_OPERATOR_TEMPLATE3

#define BOOST_OPERATOR_TEMPLATE3 (   template_name3)
Value:
template<class T, class U, class V, class B> \
struct is_chained_base< template_name3<T, U, V, B> > { \
typedef operators_detail::true_t value; \
};

Definition at line 693 of file asirfilter.h.

◆ BOOST_OPERATOR_TEMPLATE4

#define BOOST_OPERATOR_TEMPLATE4 (   template_name4)
Value:
template<class T, class U, class V, class W, class B> \
struct is_chained_base< template_name4<T, U, V, W, B> > { \
typedef operators_detail::true_t value; \
};

Definition at line 685 of file asirfilter.h.

◆ BOOST_TT_AUX_PROMOTE_FROM_INDEX

#define BOOST_TT_AUX_PROMOTE_FROM_INDEX (   N,
 
)
Value:
template<> struct promote_from_index<N,0,0> { typedef T type; }; \
template<> struct promote_from_index<N,0,1> { typedef T volatile type; }; \
template<> struct promote_from_index<N,1,0> { typedef T const type; }; \
template<> struct promote_from_index<N,1,1> { typedef T const volatile type; };

Definition at line 81 of file asirfilter.h.

◆ BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE

#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE (   T)
Value:
template<> struct need_promotion<T> \
: public integral_constant<bool, (sizeof(T) < sizeof(int))> {};

Definition at line 34 of file asirfilter.h.

◆ BOOST_TYPEOF_NESTED_TYPEDEF

#define BOOST_TYPEOF_NESTED_TYPEDEF (   name,
  expr 
)
Value:
struct name {\
typedef BOOST_TYPEOF(expr) type;\
};

Definition at line 25 of file asirfilter.h.

◆ BOOST_TYPEOF_NESTED_TYPEDEF_TPL

#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL (   name,
  expr 
)
Value:
struct name {\
typedef BOOST_TYPEOF_TPL(expr) type;\
};

Definition at line 20 of file asirfilter.h.

◆ BOOST_UBLAS_CHECK

#define BOOST_UBLAS_CHECK (   expression,
 
)
Value:
if (! (expression)) { \
std::cerr << "Check failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl; \
std::cerr << #expression << std::endl; \
e.raise (); \
}

Definition at line 219 of file asirfilter.h.

◆ BOOST_UBLAS_CHECK_EX

#define BOOST_UBLAS_CHECK_EX (   expression,
  file,
  line,
 
)
Value:
if (! (expression)) { \
std::cerr << "Check failed in file " << (file) << " at line " << (line) << ":" << std::endl; \
std::cerr << #expression << std::endl; \
e.raise (); \
}

Definition at line 225 of file asirfilter.h.

◆ BOOST_UBLAS_CHECK_FALSE

#define BOOST_UBLAS_CHECK_FALSE (   e)
Value:
std::cerr << "Check failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl; \
e.raise ();

Definition at line 216 of file asirfilter.h.

Typedef Documentation

◆ new_handler

typedef void(* new_handler) ()

If you write your own error handler to be called by new, it must be of this type.

Definition at line 97 of file asirfilter.h.

Function Documentation

◆ ASIRFilter()

ASIRFilter ( MCPdf< StateVar > *  prior,
int  resampleperiod = 0,
double  resamplethreshold = 0,
int  resamplescheme = DEFAULT_RS 
)

Constructor.

Precondition
you created the necessary models and the prior
Parameters
priorpointer to the Monte Carlo Pdf prior density
resampleperiodfixed resampling period (if desired)
resamplethresholdthreshold used when dynamic resampling
resampleschemeresampling scheme, see header file for different defines and their meaning

Definition at line 26 of file asirfilter.h.

◆ assign()

BOOST_UBLAS_INLINE vector& assign ( const vector_expression< AE > &  ae)
inline

Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 341 of file asirfilter.h.

◆ assign_temporary()

BOOST_UBLAS_INLINE vector& assign_temporary ( vector< T, A > &  v)
inline

Assign a full vector (RHS-vector) to the current vector (LHS-vector)

Parameters
vis the source vector
Returns
a reference to a vector (i.e. the destination vector)

Definition at line 317 of file asirfilter.h.

◆ at_element()

BOOST_UBLAS_INLINE reference at_element ( size_type  i,
size_type  j 
)
inline

Access a matrix element. Here we return a reference

Parameters
ithe first coordinate of the element. By default it's the row
jthe second coordinate of the element. By default it's the column
Returns
a reference to the element

Definition at line 247 of file asirfilter.h.

◆ axpy_prod() [1/3]

BOOST_UBLAS_INLINE V& BFL::boost::numeric::ublas::axpy_prod ( const matrix_expression< E1 > &  e1,
const vector_expression< E2 > &  e2,
V &  v,
bool  init = true 
)

computes v += A x or v = A x in an optimized fashion.

Parameters
e1the matrix expression A
e2the vector expression x
vthe result vector v
inita boolean parameter
<tt>axpy_prod(A, x, v, init)</tt> implements the well known
axpy-product.  Setting \a init to \c true is equivalent to call
<tt>v.clear()</tt> before <tt>axpy_prod</tt>. Currently \a init
defaults to \c true, but this may change in the future.

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

Definition at line 240 of file asirfilter.h.

◆ axpy_prod() [2/3]

BOOST_UBLAS_INLINE V& BFL::boost::numeric::ublas::axpy_prod ( const vector_expression< E1 > &  e1,
const matrix_expression< E2 > &  e2,
V &  v,
bool  init = true 
)

computes v += AT x or v = AT x in an optimized fashion.

Parameters
e1the vector expression x
e2the matrix expression A
vthe result vector v
inita boolean parameter
<tt>axpy_prod(x, A, v, init)</tt> implements the well known
axpy-product.  Setting \a init to \c true is equivalent to call
<tt>v.clear()</tt> before <tt>axpy_prod</tt>. Currently \a init
defaults to \c true, but this may change in the future.

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

Definition at line 458 of file asirfilter.h.

◆ axpy_prod() [3/3]

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

computes M += A X or M = A X in an optimized fashion.

Parameters
e1the matrix expression A
e2the matrix expression X
mthe result matrix M
inita boolean parameter
<tt>axpy_prod(A, X, M, init)</tt> implements the well known
axpy-product.  Setting \a init to \c true is equivalent to call
<tt>M.clear()</tt> before <tt>axpy_prod</tt>. Currently \a init
defaults to \c true, but this may change in the future.

Up to now there are no specialisations.

Definition at line 696 of file asirfilter.h.

◆ clear()

BOOST_UBLAS_INLINE void clear ( )
inline

Erase all elements in the matrix For most types (int, double, etc...) it means writing 0 (zero) everywhere. For user-defined types, it could be another value if you decided it. Your type in that case must contain a default null value.

Definition at line 292 of file asirfilter.h.

◆ convertToSymmetricMatrix() [1/2]

virtual int convertToSymmetricMatrix ( MySymmetricMatrix &  sym)
virtual

Turn matrix into Symmetric one.

Convert Matrix to SymmetricMatrix Elements of matrix are copied to lower triangle of new symmetric matrix

Implements Matrix_Wrapper.

◆ convertToSymmetricMatrix() [2/2]

virtual int convertToSymmetricMatrix ( MySymmetricMatrix &  sym)
pure virtual

Turn matrix into Symmetric one.

Convert Matrix to SymmetricMatrix Elements of matrix are copied to lower triangle of new symmetric matrix

Implemented in Matrix.

◆ data() [1/2]

BOOST_UBLAS_INLINE const array_type& data ( ) const
inline

Return a constant reference to the internal storage of a dense matrix, i.e. the raw data It's type depends on the type used by the matrix to store its data

Definition at line 197 of file asirfilter.h.

◆ data() [2/2]

BOOST_UBLAS_INLINE array_type& data ( )
inline

Return a reference to the internal storage of a dense matrix, i.e. the raw data It's type depends on the type used by the matrix to store its data

Definition at line 204 of file asirfilter.h.

◆ empty()

BOOST_UBLAS_INLINE bool empty ( ) const
inline

Return true if the vector is empty (size==0)

Returns
true if empty, false otherwise

Definition at line 148 of file asirfilter.h.

◆ erase_element() [1/2]

BOOST_UBLAS_INLINE void erase_element ( size_type  i)
inline

Set element $i$ to the zero value.

Parameters
iindex of the element

Definition at line 264 of file asirfilter.h.

◆ erase_element() [2/2]

void erase_element ( size_type  i,
size_type  j 
)
inline

Erase the element For most types (int, double, etc...) it means setting 0 (zero) the element at zero in fact. For user-defined types, it could be another value if you decided it. Your type in that case must contain a default null value.

Parameters
ithe first coordinate of the element. By default it's the row
jthe second coordinate of the element. By default it's the column

Definition at line 281 of file asirfilter.h.

◆ find() [1/2]

BOOST_UBLAS_INLINE const_iterator find ( size_type  i) const
inline

Return a const iterator to the element i.

Parameters
iindex of the element

Definition at line 496 of file asirfilter.h.

◆ find() [2/2]

BOOST_UBLAS_INLINE iterator find ( size_type  i)
inline

Return an iterator to the element i.

Parameters
iindex of the element

Definition at line 507 of file asirfilter.h.

◆ find_element() [1/2]

BOOST_UBLAS_INLINE pointer find_element ( size_type  i)
inline

Return a pointer to the element $i$.

Parameters
iindex of the element

Definition at line 202 of file asirfilter.h.

◆ find_element() [2/2]

BOOST_UBLAS_INLINE const_pointer find_element ( size_type  i) const
inline

Return a const pointer to the element $i$.

Parameters
iindex of the element

Definition at line 210 of file asirfilter.h.

◆ insert_element() [1/2]

BOOST_UBLAS_INLINE reference insert_element ( size_type  i,
const_reference  t 
)
inline

Set element $i$ to the value t.

Parameters
iindex of the element
treference to the value to be set

Definition at line 257 of file asirfilter.h.

◆ insert_element() [2/2]

BOOST_UBLAS_INLINE reference insert_element ( size_type  i,
size_type  j,
const_reference  t 
)
inline

Change the value of a matrix element. Return back a reference to it

Parameters
ithe first coordinate of the element. By default it's the row
jthe second coordinate of the element. By default it's the column
tthe new value of the element
Returns
a reference to the newly changed element

Definition at line 270 of file asirfilter.h.

◆ matrix() [1/5]

BOOST_UBLAS_INLINE matrix ( size_type  size1,
size_type  size2 
)
inline

Dense matrix constructor with defined size

Parameters
size1number of rows
size2number of columns

Definition at line 131 of file asirfilter.h.

◆ matrix() [2/5]

matrix ( size_type  size1,
size_type  size2,
const value_type &  init 
)
inline

Dense matrix constructor with defined size a initial value for all the matrix elements

Parameters
size1number of rows
size2number of columns
initinitial value assigned to all elements

Definition at line 141 of file asirfilter.h.

◆ matrix() [3/5]

BOOST_UBLAS_INLINE matrix ( size_type  size1,
size_type  size2,
const array_type &  data 
)
inline

Dense matrix constructor with defined size and an initial data array

Parameters
size1number of rows
size2number of columns
dataarray to copy into the matrix. Must have the same dimension as the matrix

Definition at line 152 of file asirfilter.h.

◆ matrix() [4/5]

BOOST_UBLAS_INLINE matrix ( const matrix< T, L, A > &  m)
inline

Copy-constructor of a dense matrix

Parameters
mis a dense matrix

Definition at line 160 of file asirfilter.h.

◆ matrix() [5/5]

BOOST_UBLAS_INLINE matrix ( const matrix_expression< AE > &  ae)
inline

Copy-constructor of a dense matrix from a matrix expression

Parameters
aeis a matrix expression

Definition at line 169 of file asirfilter.h.

◆ minus_assign()

BOOST_UBLAS_INLINE vector& minus_assign ( const vector_expression< AE > &  ae)
inline

Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 422 of file asirfilter.h.

◆ opb_prod()

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

computes M += A X or M = A X in an optimized fashion.

Parameters
e1the matrix expression A
e2the matrix expression X
mthe result matrix M
inita boolean parameter
<tt>opb_prod(A, X, M, init)</tt> implements the well known
axpy-product. Setting \a init to \c true is equivalent to call
<tt>M.clear()</tt> before <tt>opb_prod</tt>. Currently \a init
defaults to \c true, but this may change in the future.

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

Definition at line 806 of file asirfilter.h.

◆ operator()() [1/4]

BOOST_UBLAS_INLINE const_reference operator() ( size_type  i) const
inline

Return a const reference to the element $i$ Return a const reference to the element $i$. With some compilers, this notation will be faster than [i].

Parameters
iindex of the element

Definition at line 222 of file asirfilter.h.

◆ operator()() [2/4]

BOOST_UBLAS_INLINE reference operator() ( size_type  i)
inline

Return a reference to the element $i$ Return a reference to the element $i$. With some compilers, this notation will be faster than [i].

Parameters
iindex of the element

Definition at line 230 of file asirfilter.h.

◆ operator()() [3/4]

BOOST_UBLAS_INLINE const_reference operator() ( size_type  i,
size_type  j 
) const
inline

Access a matrix element. Here we return a const reference

Parameters
ithe first coordinate of the element. By default it's the row
jthe second coordinate of the element. By default it's the column
Returns
a const reference to the element

Definition at line 237 of file asirfilter.h.

◆ operator()() [4/4]

BOOST_UBLAS_INLINE reference operator() ( size_type  i,
size_type  j 
)
inline

Access a matrix element. Here we return a reference

Parameters
ithe first coordinate of the element. By default it's the row
jthe second coordinate of the element. By default it's the column
Returns
a reference to the element

Definition at line 257 of file asirfilter.h.

◆ operator*()

BOOST_UBLAS_INLINE const_reference operator* ( ) const
inline

Dereference an iterator Dereference an iterator: a bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds.

Returns
a const reference to the value pointed by the iterator

Definition at line 588 of file asirfilter.h.

◆ operator*=()

BOOST_UBLAS_INLINE vector& operator*= ( const AT &  at)
inline

Assign the product of the vector and a scalar to the vector Assign the product of the vector and a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector.

Template Parameters
AEis the type of the vector_expression
Parameters
atis a const reference to the scalar
Returns
a reference to the resulting vector

Definition at line 435 of file asirfilter.h.

◆ operator++()

BOOST_UBLAS_INLINE const_iterator& operator++ ( )
inline

Increment by 1 the position of the iterator.

Returns
a reference to the const iterator

Definition at line 548 of file asirfilter.h.

◆ operator+=() [1/3]

BOOST_UBLAS_INLINE vector& operator+= ( const vector_expression< AE > &  ae)
inline

Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 358 of file asirfilter.h.

◆ operator+=() [2/3]

BOOST_UBLAS_INLINE vector& operator+= ( const vector_container< C > &  v)
inline

Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 371 of file asirfilter.h.

◆ operator+=() [3/3]

BOOST_UBLAS_INLINE const_iterator& operator+= ( difference_type  n)
inline

Increment by n the position of the iterator.

Returns
a reference to the const iterator

Definition at line 564 of file asirfilter.h.

◆ operator--()

BOOST_UBLAS_INLINE const_iterator& operator-- ( )
inline

Decrement by 1 the position of the iterator.

Returns
a reference to the const iterator

Definition at line 556 of file asirfilter.h.

◆ operator-=() [1/3]

BOOST_UBLAS_INLINE vector& operator-= ( const vector_expression< AE > &  ae)
inline

Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression

Definition at line 396 of file asirfilter.h.

◆ operator-=() [2/3]

BOOST_UBLAS_INLINE vector& operator-= ( const vector_container< C > &  v)
inline

Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 409 of file asirfilter.h.

◆ operator-=() [3/3]

BOOST_UBLAS_INLINE const_iterator& operator-= ( difference_type  n)
inline

Decrement by n the position of the iterator.

Returns
a reference to the const iterator

Definition at line 572 of file asirfilter.h.

◆ operator/=()

BOOST_UBLAS_INLINE vector& operator/= ( const AT &  at)
inline

Assign the division of the vector by a scalar to the vector Assign the division of the vector by a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector.

Template Parameters
AEis the type of the vector_expression
Parameters
atis a const reference to the scalar
Returns
a reference to the resulting vector

Definition at line 448 of file asirfilter.h.

◆ operator<()

BOOST_UBLAS_INLINE bool operator< ( const const_iterator it) const
inline

compare the value of two iterators

Returns
return true if the left-hand-side iterator refers to a value placed before the right-hand-side iterator

Definition at line 632 of file asirfilter.h.

◆ operator<<() [1/4]

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

output stream operator for matrix expressions

it outpus the content of a $(M \times N)$ matrix to a standard output stream using the following format: ,

For example:

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

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

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

Parameters
osis a standard basic output stream
mis a matrix expression
Returns
a reference to the resulting output stream

Definition at line 150 of file asirfilter.h.

◆ operator<<() [2/4]

ostream& BFL::BFL::operator<< ( ostream &  stream,
WeightedSample< S > &  mws 
)
Parameters
streamthe stream to be returned
mwsthe weighted sample to be printed
Returns
the stream :-)

Definition at line 116 of file asirfilter.h.

◆ operator<<() [3/4]

ostream& BFL::BFL::operator<< ( ostream &  stream,
Sample< S > &  my_sample 
)
Parameters
streamthe stream to be returned
my_samplethe sample to be printed
Returns
the stream :-)

Definition at line 155 of file asirfilter.h.

◆ operator<<() [4/4]

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

output stream operator for vector expressions

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

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

will display the some of the 2 vectors like this:

[3](0.5,2.5,4.5)
Parameters
osis a standard basic output stream
vis a vector expression
Returns
a reference to the resulting output stream

Definition at line 48 of file asirfilter.h.

◆ operator=() [1/3]

BOOST_UBLAS_INLINE vector& operator= ( const vector< T, A > &  v)
inline

Assign a full vector (RHS-vector) to the current vector (LHS-vector)

Parameters
vis the source vector
Returns
a reference to a vector (i.e. the destination vector)

Definition at line 295 of file asirfilter.h.

◆ operator=() [2/3]

BOOST_UBLAS_INLINE vector& operator= ( const vector_container< C > &  v)
inline

Assign a full vector (RHS-vector) to the current vector (LHS-vector) Assign a full vector (RHS-vector) to the current vector (LHS-vector). This method does not create any temporary.

Parameters
vis the source vector container
Returns
a reference to a vector (i.e. the destination vector)

Definition at line 307 of file asirfilter.h.

◆ operator=() [3/3]

BOOST_UBLAS_INLINE vector& operator= ( const vector_expression< AE > &  ae)
inline

Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 329 of file asirfilter.h.

◆ operator==()

BOOST_UBLAS_INLINE bool operator== ( const const_iterator it) const
inline

compare the value of two itetarors

Returns
true if they reference the same element

Definition at line 623 of file asirfilter.h.

◆ operator>>() [1/3]

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

input stream operator for vectors

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

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

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

You can use it like this

my_input_stream >> my_vector;

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

Parameters
isis a standard basic input stream
vis a vector
Returns
a reference to the resulting input stream

Definition at line 89 of file asirfilter.h.

◆ operator>>() [2/3]

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

input stream operator for matrices

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

From a file or any valid standard stream, the format is: ,

You can use it like this

my_input_stream >> my_matrix;

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

Parameters
isis a standard basic input stream
mis a matrix
Returns
a reference to the resulting input stream

Definition at line 201 of file asirfilter.h.

◆ operator>>() [3/3]

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

special input stream operator for symmetric matrices

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

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

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

You can use it like this

my_input_stream >> my_symmetric_matrix;

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

Parameters
isis a standard basic input stream
mis a symmetric_matrix
Returns
a reference to the resulting input stream

Definition at line 283 of file asirfilter.h.

◆ operator[]() [1/3]

BOOST_UBLAS_INLINE const_reference operator[] ( size_type  i) const
inline

Return a const reference to the element $i$.

Parameters
iindex of the element

Definition at line 237 of file asirfilter.h.

◆ operator[]() [2/3]

BOOST_UBLAS_INLINE reference operator[] ( size_type  i)
inline

Return a reference to the element $i$.

Parameters
iindex of the element

Definition at line 244 of file asirfilter.h.

◆ operator[]() [3/3]

BOOST_UBLAS_INLINE const_reference operator[] ( difference_type  n) const
inline

Dereference an iterator at the n-th forward value Dereference an iterator at the n-th forward value, that is the value pointed by iterator+n.

A bounds' check is done before returning the value. A bad_index() expection is returned if out of bounds.

Returns
a const reference

Definition at line 598 of file asirfilter.h.

◆ plus_assign()

BOOST_UBLAS_INLINE vector& plus_assign ( const vector_expression< AE > &  ae)
inline

Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting vector.

Template Parameters
AEis the type of the vector_expression
Parameters
aeis a const reference to the vector_expression
Returns
a reference to the resulting vector

Definition at line 384 of file asirfilter.h.

◆ resize() [1/3]

BOOST_UBLAS_INLINE void resize ( size_type  size,
bool  preserve = true 
)
inline

Resize the vector Resize the vector to a new size. If preserve is true, data are copied otherwise data are lost. If the new size is bigger, the remaining values are filled in with the initial value (0 by default) in the case of unbounded_array, which is the container by default. If the new size is smaller, last values are lost. This behaviour can be different if you explicitely specify another type of container.

Parameters
sizenew size of the vector
preserveif true, keep values

Definition at line 187 of file asirfilter.h.

◆ resize() [2/3]

BOOST_UBLAS_INLINE void resize ( size_type  size1,
size_type  size2,
bool  preserve = true 
)
inline

Resize a matrix to new dimensions If data are preserved, then if the size if bigger at least on one dimension, extra values are filled with zeros. If data are not preserved, then nothing has to be assumed regarding the content of the matrix after resizing.

Parameters
size1the new number of rows
size2the new number of colums
preservea boolean to say if one wants the data to be preserved during the resizing. Default is true.

Definition at line 217 of file asirfilter.h.

◆ resize() [3/3]

BOOST_UBLAS_INLINE void resize ( size_type  size,
bool  = true 
)
inline

Resize the vector. The values are preserved by default (i.e. the index does not change)

Parameters
sizeis the new size of the vector

Definition at line 1973 of file asirfilter.h.

◆ Sample()

Sample ( unsigned int  dimension = 0)

Constructor.

Parameters
dimensionof the ColumnVector for the continuous samples. This parameter is ignored in the discrete case.

Definition at line 108 of file asirfilter.h.

◆ serialize()

void serialize ( Archive &  ar,
const unsigned int   
)
inline

Serialize a vector into and archive as defined in Boost

Parameters
arArchive object. Can be a flat file, an XML file or any other stream
file_versionOptional file version (not yet used)

Definition at line 820 of file asirfilter.h.

◆ set_new_handler()

new_handler BFL::std::set_new_handler ( new_handler  )
throw (
)

Takes a replacement handler as the argument, returns the previous handler.

◆ size1()

BOOST_UBLAS_INLINE size_type size1 ( ) const
inline

Return the number of rows of the matrix You can also use the free size<>() function in operation/size.hpp as size<1>(m) where m is a matrix

Definition at line 180 of file asirfilter.h.

◆ size2()

BOOST_UBLAS_INLINE size_type size2 ( ) const
inline

Return the number of colums of the matrix You can also use the free size<>() function in operation/size.hpp as size<2>(m) where m is a matrix

Definition at line 188 of file asirfilter.h.

◆ swap()

BOOST_UBLAS_INLINE void swap ( vector< T, A > &  v)
inline

Swap the content of the vector with another vector.

Parameters
vis the vector to be swapped with

Definition at line 460 of file asirfilter.h.

◆ unit_vector()

BOOST_UBLAS_INLINE unit_vector ( size_type  size,
size_type  index = 0 
)
inlineexplicit

Constructor of unit_vector.

Parameters
sizeis the dimension of the vector
indexis the order of the vector

Definition at line 1942 of file asirfilter.h.

◆ ValueSet()

void ValueSet ( const T &  value)

Set the value of the Sample.

Parameters
valuethe value indeed :-)

Definition at line 125 of file asirfilter.h.

◆ vector() [1/6]

BOOST_UBLAS_INLINE vector ( size_type  size)
inlineexplicit

Constructor of a vector with a predefined size By default, its elements are initialized to 0.

Parameters
sizeinitial size of the vector

Definition at line 84 of file asirfilter.h.

◆ vector() [2/6]

BOOST_UBLAS_INLINE vector ( size_type  ,
const array_type &  data 
)
inline

Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition.

Parameters
sizeinitial size of the vector
Bug:
this value is not used
Parameters
datacontainer of type A
Todo:
remove this definition because size is not used

Definition at line 95 of file asirfilter.h.

◆ vector() [3/6]

BOOST_UBLAS_INLINE vector ( const array_type &  data)
inline

Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition.

Parameters
datacontainer of type A

Definition at line 103 of file asirfilter.h.

◆ vector() [4/6]

BOOST_UBLAS_INLINE vector ( size_type  size,
const value_type &  init 
)
inline

Constructor of a vector with a predefined size and a unique initial value.

Parameters
sizeof the vector
initvalue to assign to each element of the vector

Definition at line 111 of file asirfilter.h.

◆ vector() [5/6]

BOOST_UBLAS_INLINE vector ( const vector< T, A > &  v)
inline

Copy-constructor of a vector.

Parameters
vis the vector to be duplicated

Definition at line 118 of file asirfilter.h.

◆ vector() [6/6]

BOOST_UBLAS_INLINE vector ( const vector_expression< AE > &  ae)
inline

Copy-constructor of a vector from a vector_expression Depending on the vector_expression, this constructor can have the cost of the computations of the expression (trivial to say it, but it is to take into account in your complexity calculations).

Parameters
aethe vector_expression which values will be duplicated into the vector

Definition at line 128 of file asirfilter.h.

◆ WeightedSample()

WeightedSample ( int  dimension = 0)

Constructor.

Parameters
dimensionof the ColumnVector for the continuous samples, number of discrete states for the discrete case

Definition at line 93 of file asirfilter.h.

◆ WeightGet()

double WeightGet ( ) const

Get the weight.

Returns
the weight

Definition at line 104 of file asirfilter.h.

◆ WeightSet()

void WeightSet ( double  weight)

Set the weight.

Parameters
weightthe weight :-)
Returns
true if weight is a reasonable value

Definition at line 109 of file asirfilter.h.

◆ what() [1/2]

virtual const char* what ( ) const
virtual

Returns a C-style character string describing the general cause of the current error.

Reimplemented from exception.

◆ what() [2/2]

virtual const char* what ( ) const
throw (
)
virtual

Returns a C-style character string describing the general cause of the current error.

Reimplemented from exception.

Variable Documentation

◆ size

const std::size_t size
static
Initial value:
= sizeof (
type_deduction_detail::test<
typename base_type::x_type
, typename base_type::y_type
>(x + y)
)

Definition at line 150 of file asirfilter.h.

◆ value

constexpr bool value
static
Initial value:
= addressof_expression<T>::value &&
!addressof_member_operator<T>::value &&
!addressof_non_member_operator<T>::value

Definition at line 222 of file asirfilter.h.

Friends

◆ operator<< [1/2]

ostream& operator<< ( ostream &  stream,
WeightedSample< S > &  mws 
)
friend

Print a weighted sample.

Parameters
streamthe stream to be returned
mwsthe weighted sample to be printed
Returns
the stream :-)

Definition at line 116 of file asirfilter.h.

◆ operator<< [2/2]

ostream& operator<< ( ostream &  stream,
Sample< S > &  my_sample 
)
friend

Print a sample.

Parameters
streamthe stream to be returned
my_samplethe sample to be printed
Returns
the stream :-)

Definition at line 155 of file asirfilter.h.

◆ swap

BOOST_UBLAS_INLINE friend void swap ( vector< T, A > &  v1,
vector< T, A > &  v2 
)
friend

Swap the content of two vectors.

Parameters
v1is the first vector. It takes values from v2
v2is the second vector It takes values from v1

Definition at line 470 of file asirfilter.h.