rheolef Namespace Reference

irheostream, orheostream - large data streams More...

Namespaces
namespace	algo
namespace	details
namespace	vec_detail
namespace	custom_cgal
namespace	prism
namespace	hexahedron
namespace	element_constant
namespace	field_detail
namespace	detail
namespace	detail_nonlinear_expr
namespace	space_constant

Classes
struct	float_traits
struct	float_traits< std::complex< T > >
class	fdoutbuf
class	fdostream
class	fdinbuf
class	fdistream
class	opstream
class	ipstream
class	catchmark
	catchmark - iostream manipulator More...
class	heap_allocator
	heap_allocator - heap-based allocator More...
class	heap_object
class	iorheo
class	irheomanip1
class	orheomanip1
class	iorheomanip1
class	iorheobase_memory_handler
struct	get_first
struct	get_second
struct	promote_not_specialized_for_this_case
struct	promote
struct	promote< char, char >
struct	promote< char, unsigned char >
struct	promote< char, short int >
struct	promote< char, short unsigned int >
struct	promote< char, int >
struct	promote< char, unsigned int >
struct	promote< char, long >
struct	promote< char, unsigned long >
struct	promote< char, float >
struct	promote< char, double >
struct	promote< char, long double >
struct	promote< unsigned char, char >
struct	promote< unsigned char, unsigned char >
struct	promote< unsigned char, short int >
struct	promote< unsigned char, short unsigned int >
struct	promote< unsigned char, int >
struct	promote< unsigned char, unsigned int >
struct	promote< unsigned char, long >
struct	promote< unsigned char, unsigned long >
struct	promote< unsigned char, float >
struct	promote< unsigned char, double >
struct	promote< unsigned char, long double >
struct	promote< short int, char >
struct	promote< short int, unsigned char >
struct	promote< short int, short int >
struct	promote< short int, short unsigned int >
struct	promote< short int, int >
struct	promote< short int, unsigned int >
struct	promote< short int, long >
struct	promote< short int, unsigned long >
struct	promote< short int, float >
struct	promote< short int, double >
struct	promote< short unsigned int, char >
struct	promote< short unsigned int, unsigned char >
struct	promote< short unsigned int, short int >
struct	promote< short unsigned int, short unsigned int >
struct	promote< short unsigned int, int >
struct	promote< short unsigned int, unsigned int >
struct	promote< short unsigned int, long >
struct	promote< short unsigned int, unsigned long >
struct	promote< short unsigned int, float >
struct	promote< short unsigned int, double >
struct	promote< short unsigned int, long double >
struct	promote< int, char >
struct	promote< int, unsigned char >
struct	promote< int, short int >
struct	promote< int, short unsigned int >
struct	promote< int, int >
struct	promote< int, unsigned int >
struct	promote< int, long >
struct	promote< int, unsigned long >
struct	promote< int, float >
struct	promote< int, double >
struct	promote< int, long double >
struct	promote< unsigned int, char >
struct	promote< unsigned int, unsigned char >
struct	promote< unsigned int, short int >
struct	promote< unsigned int, short unsigned int >
struct	promote< unsigned int, int >
struct	promote< unsigned int, unsigned int >
struct	promote< unsigned int, long >
struct	promote< unsigned int, unsigned long >
struct	promote< unsigned int, float >
struct	promote< unsigned int, double >
struct	promote< unsigned int, long double >
struct	promote< long, char >
struct	promote< long, unsigned char >
struct	promote< long, short int >
struct	promote< long, short unsigned int >
struct	promote< long, int >
struct	promote< long, unsigned int >
struct	promote< long, long >
struct	promote< long, unsigned long >
struct	promote< long, float >
struct	promote< long, double >
struct	promote< long, long double >
struct	promote< unsigned long, char >
struct	promote< unsigned long, unsigned char >
struct	promote< unsigned long, short int >
struct	promote< unsigned long, short unsigned int >
struct	promote< unsigned long, int >
struct	promote< unsigned long, unsigned int >
struct	promote< unsigned long, long >
struct	promote< unsigned long, unsigned long >
struct	promote< unsigned long, float >
struct	promote< unsigned long, double >
struct	promote< unsigned long, long double >
struct	promote< float, char >
struct	promote< float, unsigned char >
struct	promote< float, short int >
struct	promote< float, short unsigned int >
struct	promote< float, int >
struct	promote< float, unsigned int >
struct	promote< float, long >
struct	promote< float, unsigned long >
struct	promote< float, float >
struct	promote< float, double >
struct	promote< float, long double >
struct	promote< double, char >
struct	promote< double, unsigned char >
struct	promote< double, short int >
struct	promote< double, short unsigned int >
struct	promote< double, int >
struct	promote< double, unsigned int >
struct	promote< double, long >
struct	promote< double, unsigned long >
struct	promote< double, float >
struct	promote< double, double >
struct	promote< double, long double >
struct	promote< long double, char >
struct	promote< long double, unsigned char >
struct	promote< long double, short int >
struct	promote< long double, short unsigned int >
struct	promote< long double, int >
struct	promote< long double, unsigned int >
struct	promote< long double, long >
struct	promote< long double, unsigned long >
struct	promote< long double, float >
struct	promote< long double, double >
struct	promote< long double, long double >
class	irheostream
class	orheostream
class	smart_pointer_base
class	smart_pointer
class	smart_pointer_clone
class	smart_pointer_nocopy
class	stack_allocator
struct	vector_rep
struct	Vector
struct	VectorOfIterators
struct	_array_put_element_type
struct	_array_put_matlab_type
struct	_array_get_element_type
class	array_rep
class	array_rep< T, sequential, A >
class	array_rep< T, distributed, A >
class	array
	array - container in distributed environment More...
class	array< T, sequential, A >
class	array< T, distributed, A >
struct	array_store
struct	array_store< OutputRandomIterator, SetOp, Size, boost::mpl::false_ >
struct	array_store< OutputRandomIterator, SetOp, Size, boost::mpl::true_ >
class	asr
	asr - associative sparse matrix More...
struct	is_dia_t
struct	default_set_op
struct	is_container
struct	is_container_of_mpi_datatype
class	csr_rep
class	csr_rep< T, sequential >
class	csr_rep< T, distributed >
class	csr
	csr - compressed sparse row matrix More...
class	csr< T, sequential >
class	csr< T, distributed >
struct	vec_trans
struct	vector_vec_trans
struct	csr_concat_value
struct	csr_concat_line
class	csr_concat
struct	op_ext2glob_t
struct	op_dia_t
struct	op_dis_j2jext_t
class	dia
	dia - diagonal matrix More...
struct	sequential
struct	is_sequential
struct	is_distributed
struct	distributed
struct	is_sequential< distributed >
struct	is_distributed< distributed >
class	distributor
	distributor - data distribution table More...
class	odiststream
class	environment
class	eye
	eye - the identity matrix More...
class	unary_compose
class	binary_compose
class	index_set
	index_set - a set of indexes More...
struct	index_set_add_op
struct	default_set_op< index_set >
struct	is_container< index_set >
struct	is_container_of_mpi_datatype< index_set >
struct	abtbc_schur_complement
struct	abtb_schur_complement
struct	msg_right_permutation_set_default
struct	select1st
struct	select2nd
struct	always_true
struct	set_op
struct	set_add_op
class	dummy_iterator
class	index_iterator
struct	first_op
struct	second_op
struct	pair_identity
class	apply_iterator
class	pair_set
	pair_set - a set of (index,value) pair More...
struct	pair_set_add_op
struct	default_set_op< pair_set< T, A > >
struct	is_container< pair_set< T, A > >
struct	is_container_of_mpi_datatype< pair_set< T, A > >
class	scatter_message
class	scatter_message< Container, false >
class	scatter_message< Container, true >
class	solver_option_type
class	solver_abstract_rep
class	solver_rep
class	solver_basic
	solver - direct or interative solver interface More...
class	solver_abtb_basic
	solver_abtb – direct or iterative solver iterface for mixed linear systems More...
class	solver_mumps_rep
class	solver_trilinos_ifpack_rep
class	solver_wrapper_rep
class	vec
	vec - vector in distributed environment More...
struct	vec_concat_value
struct	vec_concat
struct	vec_iterator_wrapper
struct	vec_begin
struct	vec_grammar_begin
struct	vec_dereference_context
struct	vec_increment_context
struct	vec_subscript_context
struct	vec_get_size_context
struct	vec_check_size_context
struct	vec_assign_operators
struct	vec_assign_operators_cases
struct	vec_grammar
struct	vec_domain
struct	vec_expr
struct	is_vec
struct	is_vec< vec< T, M > >
class	vec_range
class	vec_range_const
class	vector_of_iterator
struct	geo_cgal_traits
struct	geo_cgal_traits< T, 1 >
struct	geo_cgal_traits< T, 2 >
struct	geo_cgal_traits< T, 3 >
class	geo_element_indirect
class	geo_element
	geo_element - element of a mesh More...
class	geo_element_auto
class	geo_element_hack
struct	geo_element_permuted_put
struct	hack_array_iterator
class	hack_array_seq_rep
class	hack_array_mpi_rep
class	hack_array
	hack_array - container in distributed environment More...
class	hack_array< T, sequential, A >
class	hack_array< T, distributed, A >
class	point_basic
	point - vertex of a mesh More...
struct	scalar_traits
	helper for point_basic<T> & tensor_basic<T>: get basic T type More...
struct	scalar_traits< point_basic< T > >
struct	float_traits< point_basic< T > >
class	quadrature_option_type
	quadrature - quadrature formulae on the reference lement More...
struct	weighted_point
class	quadrature_on_geo
class	quadrature_rep
class	quadrature
class	reference_element
	reference_element - reference element More...
class	reference_element_p
class	reference_element_e
class	reference_element_t
class	reference_element_q
class	reference_element_T
class	reference_element_P
class	reference_element_H
class	tensor_basic
struct	float_traits< tensor_basic< T > >
struct	scalar_traits< tensor_basic< T > >
class	tensor4_basic
struct	float_traits< tensor4_basic< T > >
struct	scalar_traits< tensor4_basic< T > >
class	tiny_element
class	tiny_vector
class	tiny_matrix
struct	undeterminated_basic
struct	scalar_traits< undeterminated_basic< T > >
struct	float_traits< undeterminated_basic< T > >
struct	promote< undeterminated_basic< T1 >, undeterminated_basic< T2 > >
struct	promote< T1, undeterminated_basic< T2 > >
struct	promote< undeterminated_basic< T1 >, T2 >
struct	promote< point_basic< T1 >, undeterminated_basic< T2 > >
struct	promote< undeterminated_basic< T1 >, point_basic< T2 > >
struct	promote< point_basic< T1 >, point_basic< T2 > >
struct	promote< tensor_basic< T1 >, undeterminated_basic< T2 > >
struct	promote< undeterminated_basic< T1 >, tensor_basic< T2 > >
struct	promote< tensor_basic< T1 >, tensor_basic< T2 > >
struct	adapt_option_type
	adapt - mesh adaptation More...
class	any_set
	any_set - a set of any object More...
struct	any_set_add_op
class	band_basic
	band - compute the band arround a level set More...
class	basis_rep
class	basis_basic
	basis - polynomial basis More...
class	basis_on_pointset
class	branch_basic
	branch - a parameter-dependent sequence of field More...
class	__branch_header
class	__const_branch_header
class	__const_branch_finalize
class	__obranch
class	__iobranch
class	characteristic_element
struct	characteristic_on_quadrature_rep
class	characteristic_on_quadrature
class	characteristic_rep
class	characteristic_basic
	characteristic - the Lagrange-Galerkin method implemented More...
class	field_o_characteristic
struct	newton_identity_preconditioner
	damped_newton – damped Newton nonlinear algorithm More...
class	domain_indirect_base_rep
class	domain_indirect_rep
class	domain_indirect_rep< sequential >
class	domain_indirect_rep< distributed >
class	domain_indirect_basic
	domain_indirect - a named part of a finite element mesh More...
class	domain_indirect_basic< sequential >
class	domain_indirect_basic< distributed >
struct	field_put
struct	field_put< T, sequential >
class	field_basic
	field - piecewise polynomial finite element field More...
class	field_component
class	field_component_const
struct	field_concat_value
struct	field_concat
class	field_element
struct	field_iterator_wrapper
struct	field_begin
struct	field_grammar_begin
struct	field_dereference_context
struct	field_increment_context
struct	field_subscript_context
struct	field_get_size_context
struct	field_get_space_context
struct	field_check_stamp_context
struct	field_assign_operators
struct	field_assign_operators_cases
struct	field_terminal
struct	field_constant_expr
struct	field_grammar
struct	field_domain
struct	field_expr
struct	is_field
struct	is_field< field_basic< T, M > >
struct	is_field< field_indirect< T, M > >
struct	is_field< field_indirect_const< T, M > >
struct	is_field< field_component< T, M > >
struct	is_field< field_component_const< T, M > >
class	field_indirect
class	field_indirect_const
class	field_expr_terminal_function_rep
class	field_expr_terminal_function
class	field_expr_terminal_field_rep
class	field_expr_terminal_field
class	field_nonlinear_expr
struct	generic_unary_traits
class	field_nonlinear_expr_uf
struct	generic_binary_traits
class	field_nonlinear_expr_bf
struct	compose_result
struct	compose_result< Function, field_basic< T, M > >
struct	generic_unary_traits< detail_nonlinear_expr::unary_plus >
struct	generic_unary_traits< detail_nonlinear_expr::negate >
struct	generic_binary_traits< detail_nonlinear_expr::plus >
struct	generic_binary_traits< detail_nonlinear_expr::minus >
struct	generic_binary_traits< detail_nonlinear_expr::multiplies >
struct	generic_binary_traits< detail_nonlinear_expr::divides >
struct	generic_unary_traits< detail_nonlinear_expr::norm_ >
struct	generic_unary_traits< detail_nonlinear_expr::norm2_ >
class	field_on_pointset_rep
class	field_on_pointset
struct	bound_type
struct	id
class	form_basic
	form - representation of a finite element bilinear form More...
struct	form_concat_value
struct	form_concat_line
struct	form_concat
class	form_element_rep
class	form_element
	form_element - bilinear form on a single element More...
struct	_point_get
struct	_point_put
struct	geo_iterator
class	geo_abstract_base_rep
class	geo_abstract_rep
class	geo_abstract_rep< T, sequential >
class	geo_abstract_rep< T, distributed >
class	geo_base_rep
class	geo_rep
class	geo_rep< T, sequential >
class	geo_rep< T, distributed >
class	geo_basic
class	geo_basic< T, sequential >
class	geo_basic< T, distributed >
	distributed mesh with rerefence counting More...
class	geo_domain_rep
	geo_domain - a named part of a finite element mesh that behaves as a mesh More...
class	geo_domain_indirect_base_rep
class	geo_domain_indirect_rep
class	geo_domain_indirect_rep< T, sequential >
class	geo_domain_indirect_rep< T, distributed >
class	curved_ball_q
class	curved_ball_t
class	curved_ball_T
class	curved_ball_H
struct	geo_header
class	Segment_tree_map_traits_1
struct	cgal_locate_traits
struct	cgal_locate_traits< T, 1 >
struct	cgal_locate_traits< T, 2 >
struct	cgal_locate_traits< T, 3 >
class	geo_locate_abstract_rep
class	geo_locate_rep
class	geo_locate
struct	stack_node
struct	permutation_proxy
struct	MeshType
struct	KeyValueType
struct	geo_size
struct	hit_t
struct	nearest_hit
class	geo_trace_ray_boundary_abstract_rep
struct	geo_trace_ray_boundary_rep
class	geo_trace_ray_boundary_rep< T, M, 1 >
class	geo_trace_ray_boundary_rep< T, M, 2 >
class	geo_trace_ray_boundary_rep< T, M, 3 >
class	geo_trace_ray_boundary
class	iofem
class	quadruplet
struct	to_solve
struct	level_set_option_type
	level_set - compute a level set from a function More...
class	numbering_rep
class	numbering
	numbering - global degree of freedom numbering More...
struct	id_pt_t
struct	id_pt_minimum
struct	pt2_t
struct	pt2_minimum
struct	rounder_type
struct	floorer_type
struct	ceiler_type
struct	space_pair_type
class	space_base_rep
class	space_rep
class	space_rep< T, sequential >
class	space_rep< T, distributed >
class	space_basic
	space – piecewise polynomial finite element space More...
class	space_basic< T, sequential >
class	space_basic< T, distributed >
class	space_component
class	space_component_const
class	space_act
class	space_scalar_constitution_rep
class	space_scalar_constitution
class	space_constitution_rep
class	space_constitution
struct	tree_type
union	YYSTYPE
union	yyalloc
struct	yy_buffer_state
class	FlexLexer
class	yyFlexLexer
struct	yy_trans_info
struct	space_mult_list_rep
class	space_mult_list

Typedefs
typedef double	Float
typedef solver_basic< Float >	solver
typedef solver_abtb_basic < Float, rheo_default_memory_model >	solver_abtb
typedef point_basic< Float >	point
typedef reference_element_H::size_type	size_type
typedef tensor_basic< Float >	tensor
typedef tensor4_basic< Float >	tensor4
typedef band_basic< Float >	band
typedef basis_basic< Float >	basis
typedef branch_basic< Float >	branch
typedef characteristic_basic < Float >	characteristic
typedef domain_indirect_basic < rheo_default_memory_model >	domain_indirect
typedef field_basic< Float >	field
typedef field_basic< Float, sequential >	field_sequential
typedef form_basic< Float, rheo_default_memory_model >	form
typedef geo	domain
	geo_domain_indirect_rep - a named part of a finite element mesh
typedef int	my_idxtype
typedef my_idxtype	idxtype
typedef struct KeyValueType	KeyValueType
typedef geo_element_auto < heap_allocator < geo_element::size_type > >	element_type
typedef space_basic< Float >	space
typedef std::pair< std::string, std::string >	base_geo_pair
typedef std::list< tree_type >	list_type
typedef union rheolef::YYSTYPE	YYSTYPE
typedef unsigned char	yytype_uint8
typedef short int	yytype_int8
typedef unsigned short int	yytype_uint16
typedef short int	yytype_int16
typedef signed char	flex_int8_t
typedef short int	flex_int16_t
typedef int	flex_int32_t
typedef unsigned char	flex_uint8_t
typedef unsigned short int	flex_uint16_t
typedef unsigned int	flex_uint32_t
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef int	yy_state_type

Enumerations
enum	yytokentype {   IDENTIFIER = 258,   SCALAR = 259,   VECTOR = 260,   TENSOR = 261,   UNSYMMETRIC_TENSOR = 262,   TENSOR4 = 263 }

Functions
static double	sqr (const double &x)
template<class T >
T	max (T x, int y)
template<class T >
T	max (int x, T y)
template<class T >
T	min (T x, int y)
template<class T >
T	min (int x, T y)
bool	scatch (std::istream &in, const std::string &ch)
std::istream &	operator>> (std::istream &is, const catchmark &m)
std::ostream &	operator<< (std::ostream &os, const catchmark &m)
template<typename T1 >
endcode bool	operator== (const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs) throw ()
template<typename T1 >
bool	operator!= (const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs) throw ()
template<typename InputPairIterator , typename OutputPairIterator , typename UnaryOperation >
OutputPairIterator	pair_transform_second (InputPairIterator first, InputPairIterator last, OutputPairIterator result, UnaryOperation unary_op)
template<class T1 , class T2 >
std::ostream &	operator<< (std::ostream &out, const std::pair< T1, T2 > &x)
std::string	indent (std::string str, const std::string &indent=" ")
std::string	typeid_name (const char *name, bool do_indent)
	typename_macro, pretty_typename_macro - type demangler and pretty printer
template<class T >
std::string	typename_of (T x)
	get string type from a variable or expression
template<class T >
std::string	pretty_typename_of (T x)
std::string	get_tmpdir ()
string	itos (string::size_type i)
string	ftos (const Float &x)
bool	has_suffix (const string &name, const string &suffix)
string	delete_suffix (const string &name, const string &suffix)
string	get_basename (const string &name)
string	get_dirname (const string &name)
static string	get_dir_from_path (const string &path, unsigned int &i_pos)
static void	init_rheo_path ()
void	append_dir_to_rheo_path (const string &dir)
void	prepend_dir_to_rheo_path (const string &dir)
bool	file_exists (const string &filename)
static bool	have_name_in_dir (const string &dir, const string &name, string &full_path)
string	get_full_name_from_rheo_path (const string &rootname, const string &suffix)
bool	is_float (const string &s)
Float	to_float (const string &s)
std::string	itos (std::string::size_type i)
template<typename T1 >
bool	operator== (const stack_allocator< T1 > &lhs, const stack_allocator< T1 > &rhs) throw ()
template<typename T1 >
bool	operator!= (const stack_allocator< T1 > &lhs, const stack_allocator< T1 > &rhs) throw ()
double	the_clock ()
template<class T >
bool	invert (const ublas::matrix< T > &input, ublas::matrix< T > &inverse)
template<class T >
boost::numeric::ublas::matrix< T >	invert (const boost::numeric::ublas::matrix< T > &m, bool &is_singular)
template<class matrix_T >
double	determinant (ublas::matrix_expression< matrix_T > const &mat_r)
template<class T >
std::ostream &	operator<< (std::ostream &out, const ublas::vector< T > &b)
template<class T >
std::ostream &	operator<< (std::ostream &out, const ublas::matrix< T > &A)
template<class T >
bool	invert_3x3 (const ublas::matrix< T > &A, ublas::matrix< T > &result)
template<class Range1 , class Range2 >
static void	mr_set (ublas::matrix< Float > &m, Range1 r1, Range2 r2, const ublas::matrix< Float > &m_expr)
template<class T , class A >
idiststream &	operator>> (idiststream &ips, array< T, sequential, A > &x)
template<class T , class A >
odiststream &	operator<< (odiststream &ops, const array< T, sequential, A > &x)
template<class T , class A >
idiststream &	operator>> (idiststream &ips, array< T, distributed, A > &x)
template<class T , class A >
odiststream &	operator<< (odiststream &ops, const array< T, distributed, A > &x)
template<class OutputRandomIterator , class SetOp , class Size , class IsContainer >
array_store < OutputRandomIterator, SetOp, Size, IsContainer >	array_make_store (OutputRandomIterator x, SetOp op, Size, IsContainer)
void	read_mm_header (idiststream &)
	_RHEOLEF_instanciation (Float, sequential, std::allocator< Float >) _RHEOLEF_instanciation(Float
template<class T , class M , class A >
idiststream &	operator>> (idiststream &s, asr< T, M, A > &x)
template<class T , class M , class A >
odiststream &	operator<< (odiststream &s, const asr< T, M, A > &x)
template<class InputPtrIterator , class Predicate , class Operation , class OutputPtrIterator , class OutputDataIterator >
OutputPtrIterator	asr_to_csr (InputPtrIterator iter_ptr_a, InputPtrIterator last_ptr_a, Predicate pred, Operation op, OutputPtrIterator iter_ptr_b, OutputDataIterator iter_data_b)
	asr_to_csr – sequential sparse matrix convertion
template<class InputPtrIterator , class Predicate , class Set >
Set::value_type	asr_to_csr_dist_logical (InputPtrIterator iter_ptr_a, InputPtrIterator last_ptr_a, Predicate is_dia, Set &colext)
	asr_to_csr_dist_logical – sparse matrix convertion
template<class T , class M >
csr< T, M >	diag (const vec< T, M > &d)
	_RHEOLEF_instanciation (Float, sequential) _RHEOLEF_instanciation(Float
template<class T >
csr< T, sequential >	operator* (const T &lambda, const csr< T, sequential > &a)
template<class T >
csr< T, sequential >	operator- (const csr< T, sequential > &a)
template<class T >
csr< T, sequential >	trans (const csr< T, sequential > &a)
template<class T >
csr< T, distributed >	operator* (const T &lambda, const csr< T, distributed > &a)
template<class T >
csr< T, distributed >	operator- (const csr< T, distributed > &a)
template<class T >
csr< T, distributed >	trans (const csr< T, distributed > &a)
template<class T , class M , class Function >
csr< T, M >	apply (Function f, const csr< T, M > &a)
template<class T , class M , class Function >
csr< T, M >	apply (T(*f)(const T &), const csr< T, M > &a)
template<class T , class M >
idiststream &	operator>> (idiststream &s, csr< T, M > &x)
template<class T , class M >
odiststream &	operator<< (odiststream &s, const csr< T, M > &x)
template<class InputIterator1 , class InputIterator2 , class InputIterator3 , class InputIterator4 , class RandomAccessIterator , class OutputIterator1 , class OutputIterator2 , class Size , class T >
Size	xmub (InputIterator1 jx, InputIterator1 last_jx, InputIterator2 x, RandomAccessIterator ib, InputIterator3 jb, InputIterator4 b, OutputIterator1 jy, OutputIterator2 y, const Size &, const T &)
template<class InputIterator1 , class InputIterator2 , class InputIterator3 , class InputIterator4 , class InputIterator5 , class RandomAcessIterator , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 , class Size , class T >
Size	amub (InputIterator1 ia, InputIterator1 last_ia, InputIterator2 ja, InputIterator3 a, RandomAcessIterator ib, InputIterator4 jb, InputIterator5 b, OutputIterator1 ic, OutputIterator2 jc, OutputIterator3 c, const Size &, const T &)
template<class T , class M >
vec_trans< T, M >	trans (const vec< T, M > &w)
template<class T , class M >
vector_vec_trans< T, M >	trans (const std::vector< vec< T, M > > &w)
	RHEOLEF_csr_cstor (sequential) RHEOLEF_csr_cstor(distributed) template< class T
template<class InputIterator1 , class InputIterator3 , class SetOperator , class RandomAccessMutableIterator >
void	csr_cumul_trans_mult (InputIterator1 ia, InputIterator1 last_ia, InputIterator3 x, SetOperator set_op, RandomAccessMutableIterator y)
template<class T , class BinaryOp >
void	csr_ext_add (const csr_rep< T, sequential > &a, const std::vector< typename csr< T >::size_type > &jext_a2dis_j, const csr_rep< T, sequential > &b, const std::vector< typename csr< T >::size_type > &jext_b2dis_j, csr_rep< T, sequential > &c, std::vector< typename csr< T >::size_type > &jext_c2dis_j, BinaryOp binop)
template<class T >
csr_rep< T, sequential >::size_type	csr_csr_mult_size (const csr_rep< T, sequential > &a, const csr_rep< T, sequential > &b)
template<class T >
static void	csr_csr_mult (const csr_rep< T, sequential > &a, const csr_rep< T, sequential > &b, csr_rep< T, sequential > &c)
template<class InputPtrIterator , class InputDataIterator , class UnaryOperation , class OutputPtrIterator >
OutputPtrIterator	csr_to_asr (InputPtrIterator iter_ptr_a, InputPtrIterator last_ptr_a, InputDataIterator iter_data_a, UnaryOperation op, OutputPtrIterator iter_ptr_b)
	csr_to_asr – sequential sparse matrix convertion
template<class InputIterator1 , class InputIterator2 , class MutableRandomAcessIterator , class Size >
void	column_length (InputIterator1 iter_ib, InputIterator1 last_ib, InputIterator2 iter_jb, MutableRandomAcessIterator rand_ia, Size nrow_a)
template<class InputIterator >
void	pointer_from_length (InputIterator iter_ia, InputIterator last_ia)
template<class InputIterator1 , class InputIterator2 , class InputIterator3 , class MutableRandomAccessIterator1 , class MutableRandomAccessIterator2 , class MutableRandomAccessIterator3 , class Size >
void	trans_copy_values (InputIterator1 iter_ib, InputIterator1 last_ib, InputIterator2 iter_jb, InputIterator3 iter_b, MutableRandomAccessIterator1 rand_ia, MutableRandomAccessIterator2 rand_ja, MutableRandomAccessIterator3 rand_a, Size size_type_tag)
template<class InputIterator , class T >
void	right_shift (InputIterator iter_ia, InputIterator last_ia, T last_value)
template<class T , class M >
dia< T, M >	operator/ (const T &lambda, const dia< T, M > &d)
template<class T , class M >
vec< T, M >	operator* (const dia< T, M > &d, const vec< T, M > &x)
template<class T , class M >
dia< T, M >	diag (const csr< T, M > &a)@endcode
	diag - get diagonal part of a matrix
template<class InputIterator , class Size >
std::iterator_traits < InputIterator >::value_type	dis_accumulate (InputIterator first, Size n, const distributor::communicator_type &comm, sequential)
	dis_accumulate - distributed accumulate algorithm
template<class InputIterator , class Size >
std::iterator_traits < InputIterator >::value_type	dis_accumulate (InputIterator first, Size n, const distributor::communicator_type &comm, distributed)
template<class InputIterator , class Size >
std::iterator_traits < InputIterator >::value_type	dis_accumulate (InputIterator first, Size n, const distributor::communicator_type &comm)
template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits < InputIterator1 >::value_type, typename std::iterator_traits < InputIterator2 >::value_type > ::type	dis_inner_product (InputIterator1 first1, InputIterator2 first2, Size n, const distributor::communicator_type &comm, sequential)
	dis_inner_product - distributed inner product algorithm
template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits < InputIterator1 >::value_type, typename std::iterator_traits < InputIterator2 >::value_type > ::type	dis_inner_product (InputIterator1 first1, InputIterator2 first2, Size n, const distributor::communicator_type &comm, distributed)
template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits < InputIterator1 >::value_type, typename std::iterator_traits < InputIterator2 >::value_type > ::type	dis_inner_product (InputIterator1 first1, InputIterator2 first2, Size n, const distributor::communicator_type &comm)
idiststream	din (cin)
bool	dis_scatch (idiststream &ips, const communicator &comm, std::string ch)
int	dis_system (const std::string &command, const communicator &comm)
bool	dis_file_exists (const std::string &filename, const communicator &comm)
template<class T >
odiststream &	operator<< (odiststream &s, T x)
	define_sequential_odiststream_macro (char) define_sequential_odiststream_macro(int) define_sequential_odiststream_macro(unsigned int) define_sequential_odiststream_macro(long int) define_sequential_odiststream_macro(long unsigned int) define_sequential_odiststream_macro(float) define_sequential_odiststream_macro(double) define_sequential_odiststream_macro(long double) define_sequential_odiststream_macro(char *const ) define_sequential_odiststream_macro(std
bool	dis_scatch (idiststream &ips, std::string ch)
idiststream &	operator>> (idiststream &ids, const catchmark &m)
odiststream &	operator<< (odiststream &ods, const catchmark &m)
template<class _Operation1 , class _Operation2 >
unary_compose< _Operation1, _Operation2 >	compose1 (const _Operation1 &__fn1, const _Operation2 &__fn2)
template<class _Operation1 , class _Operation2 , class _Operation3 >
binary_compose< _Operation1, _Operation2, _Operation3 >	compose2 (const _Operation1 &__fn1, const _Operation2 &__fn2, const _Operation3 &__fn3)
template<class Iterator >
std::iterator_traits< Iterator > ::pointer	get_pointer_from_iterator (Iterator iter)
template<class T >
std::iterator_traits< T * > ::pointer	get_pointer_from_iterator (T *iter)
std::istream &	operator>> (std::istream &is, index_set &x)
std::ostream &	operator<< (std::ostream &os, const index_set &x)
void	set_union (const index_set &a, const index_set &b, index_set &c)
void	set_intersection (const index_set &a, const index_set &b, index_set &c)
template<class RandomIterator >
bool	load_chunk (std::istream &s, RandomIterator iter, RandomIterator last)
template<class RandomIterator , class GetFunction >
bool	load_chunk (std::istream &s, RandomIterator iter, RandomIterator last, GetFunction get_element)
template<class Matrix , class Vector , class Solver , class Preconditioner , class Size , class Real >
int	puzawa_abtbc (const Matrix &A, const Matrix &B, const Matrix &C, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, Size &max_iter, Real &tol, const Float &rho, odiststream *p_derr=0, std::string label="puzawa_abtbc")
template<class Matrix , class Vector , class Solver , class Preconditioner , class Size , class Real >
int	puzawa_abtb (const Matrix &A, const Matrix &B, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, Size &max_iter, Real &tol, const Float &rho, odiststream *p_derr=0, std::string label="puzawa_abtb")
template<class Matrix , class Vector , class VectorExpr1 , class VectorExpr2 , class Solver , class Preconditioner , class Size , class Real >
int	pcg_abtbc (const Matrix &A, const Matrix &B, const Matrix &C, Vector &u, Vector &p, const VectorExpr1 &Mf, const VectorExpr2 &Mg, const Preconditioner &S1, const Solver &inner_solver_A, Size &max_iter, Real &tol, odiststream *p_derr=0, std::string label="pcg_abtbc")
	pcg_abtb, pcg_abtbc, pminres_abtb, pminres_abtbc – solvers for mixed linear problems
template<class Matrix , class Vector , class VectorExpr1 , class VectorExpr2 , class Solver , class Preconditioner , class Size , class Real >
int	pcg_abtb (const Matrix &A, const Matrix &B, Vector &u, Vector &p, const VectorExpr1 &Mf, const VectorExpr2 &Mg, const Preconditioner &S1, const Solver &inner_solver_A, Size &max_iter, Real &tol, odiststream *p_derr=0, std::string label="pcg_abtb")
template<class Matrix , class Vector , class Solver , class Preconditioner , class Size , class Real >
int	pminres_abtbc (const Matrix &A, const Matrix &B, const Matrix &C, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, Size &max_iter, Real &tol, odiststream *p_derr=0, std::string label="pminres_abtbc")
template<class Matrix , class Vector , class Solver , class Preconditioner , class Size , class Real >
int	pminres_abtb (const Matrix &A, const Matrix &B, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, Size &max_iter, Real &tol, odiststream *p_derr=0, std::string label="pminres_abtb")
template<class Stash , class Message , class InputIterator >
Stash::size_type	mpi_assembly_begin (const Stash &stash, InputIterator first_stash_idx, InputIterator last_stash_idx, const distributor &ownership, Message &receive, Message &send)
	mpi_assembly_begin – for array or matrix
template<class Container , class Message , class Size >
Size	mpi_assembly_end (Message &receive, Message &send, Size receive_max_size, Container x)
	msgé_assembly_end – array or matrix assembly
template<class InputIterator , class Message , class Tag , class Comm >
void	mpi_scatter_begin_global (InputIterator x, Message &from, Message &to, Tag tag, Comm comm)
	mpi_scatter_begin – gather/scatter initialize
template<class InputIterator , class OutputIterator , class SetOp , class Message >
void	mpi_scatter_begin_local (InputIterator x, OutputIterator y, Message &from, Message &to, SetOp op)
template<class InputIterator , class OutputIterator , class Message >
void	mpi_scatter_begin_local (InputIterator x, OutputIterator y, Message &from, Message &to, set_op< typename Message::value_type, typename Message::value_type > op)
template<class InputIterator , class OutputIterator , class Message , class SetOp , class Tag , class Comm >
void	mpi_scatter_begin (InputIterator x, OutputIterator y, Message &from, Message &to, SetOp op, Tag tag, Comm comm)
template<class InputIterator , class OutputIterator , class Message , class SetOp , class Tag , class Comm >
void	mpi_scatter_end (InputIterator x, OutputIterator y, Message &from, Message &to, SetOp op, Tag tag, Comm comm)
	mpi_scatter_end – gather/scatter finalize
template<class Message , class Size , class SizeRandomIterator1 , class SizeRandomIterator2 , class SizeRandomIterator3 , class Tag >
void	mpi_scatter_init (Size nidx, SizeRandomIterator1 idx, Size nidy, SizeRandomIterator2 idy, Size idy_maxval, SizeRandomIterator3 ownership, Tag tag, const distributor::communicator_type &comm, Message &from, Message &to)
template<class InputIterator , class InputSet , class OutputMap >
void	mpi_scatter_map (const distributor &ownership, InputIterator local_data, const InputSet &ext_idx_set, OutputMap &ext_idx_map)@endcode
	mpi_scatter_map – gather/scatter and build map
template<class InputIterator1 , class InputIterator2 , class InputRandomIterator , class SetOp , class OutputRandomIterator >
void	msg_both_permutation_apply (InputIterator1 px, InputIterator1 last_px, InputRandomIterator x, SetOp set_op, InputIterator2 py, OutputRandomIterator y)
	msg_both_permutation_apply – sequentail apply
template<class InputIterator1 , class InputIterator2 , class InputRandomIterator , class Proc , class Size , class MutableRandomIterator , class OutputIterator >
void	msg_from_context_indices (InputIterator1 owner, InputIterator1 last_owner, InputIterator2 idy, InputRandomIterator proc2from_proc, Proc my_proc, Size idy_maxval, MutableRandomIterator ptr, OutputIterator from_idx)
	msg_from_context_indices – gather
template<class InputIterator1 , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 >
void	msg_from_context_pattern (InputIterator1 msg_size, InputIterator1 last_msg_size, OutputIterator1 from_proc, OutputIterator2 from_ptr, OutputIterator3 proc2from_proc)
	msg_from_context – gather
template<class InputIterator1 , class InputIterator2 , class SetOp , class OutputRandomIterator >
void	msg_left_permutation_apply (InputIterator1 x, SetOp op, InputIterator2 py, InputIterator2 last_py, OutputRandomIterator y)
	msg_left_permutation_apply – sequentail apply
template<class InputIterator1 , class InputIterator2 , class Size , class OutputIterator1 , class OutputIterator2 >
void	msg_local_context (InputIterator1 idx, InputIterator1 last_idx, InputIterator2 idy, Size idy_maxval, Size istart, Size ilast, OutputIterator1 to_loc_idx, OutputIterator1 last_to_loc_idx, OutputIterator2 from_loc_idy)
	msg_local_context – receive pattern
template<class InputIterator1 , class InputIterator2 >
bool	msg_local_optimize (InputIterator1 to_loc_idx, InputIterator1 last_to_loc_idx, InputIterator2 from_loc_idy)
	msg_local_optimize – local scatter optimize
template<class InputIterator , class InputRandomIterator , class OutputIterator , class SetOp >
OutputIterator	msg_right_permutation_apply (InputIterator perm, InputIterator last_perm, const InputRandomIterator &x, OutputIterator y, SetOp set_op)
	msg_right_permutation_apply – sequentail apply
template<class InputIterator , class InputRandomIterator , class OutputIterator >
OutputIterator	msg_right_permutation_apply (InputIterator perm, InputIterator last_perm, const InputRandomIterator &x, OutputIterator y)
template<class Size , class SizeRandomIterator , class T >
void	sort_with_permutation (Size n, T *v, SizeRandomIterator vdx)
template<class InputIterator1 , class InputRandomIterator2 , class InputRandomIterator3 , class InputRandomIterator4 , class Size , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 >
void	msg_to_context (InputIterator1 perm, InputIterator1 last_perm, InputRandomIterator2 r_iproc, InputRandomIterator3 r_size, InputRandomIterator4 r_idx, Size receive_max_size, Size istart, OutputIterator1 to_proc, OutputIterator2 to_ptr, OutputIterator3 to_idx)
	msg_to_context – receive pattern
template<class Iterator , class Operator >
apply_iterator< Iterator, Operator >	make_apply_iterator (Iterator i, Operator op)
template<class InputIterator , class OutputIterator >
OutputIterator	msg_pair_copy (InputIterator input, InputIterator last, OutputIterator result)
template<class T , class A >
std::istream &	operator>> (std::istream &is, pair_set< T, A > &a)
template<class T , class A >
std::ostream &	operator<< (std::ostream &os, const pair_set< T, A > &b)
template<class Matrix , class Vector , class Vector2 , class Preconditioner , class Real , class Size >
int	pcg (const Matrix &A, Vector &x, const Vector2 &Mb, const Preconditioner &M, Size &max_iter, Real &tol, odiststream *p_derr=0, std::string label="cg")
	pcg – conjugate gradient algorithm.
template<class SmallMatrix , class Vector , class SmallVector , class Size >
void	Update (Vector &x, Size k, SmallMatrix &h, SmallVector &s, Vector v[])
template<class Real >
void	GeneratePlaneRotation (Real &dx, Real &dy, Real &cs, Real &sn)
template<class Real >
void	ApplyPlaneRotation (Real &dx, Real &dy, Real &cs, Real &sn)
template<class Matrix , class Vector , class Preconditioner , class SmallMatrix , class SmallVector , class Real , class Size >
int	pgmres (const Matrix &A, Vector &x, const Vector &b, const Preconditioner &M, SmallMatrix &H, const SmallVector &, const Size &m, Size &max_iter, Real &tol)
template<class Matrix , class Vector , class Preconditioner , class Real , class Size >
int	pminres (const Matrix &A, Vector &x, const Vector &Mb, const Preconditioner &M, Size &max_iter, Real &tol, odiststream *p_derr=0, std::string label="minres")
	pminres – conjugate gradient algorithm.
template<class Matrix , class Vector , class Preconditioner , class Real , class Size >
int	puzawa (const Matrix &A, Vector &x, const Vector &Mb, const Preconditioner &M, Size &max_iter, Real &tol, const Real &rho, odiststream *p_derr, std::string label)
	puzawa – Uzawa algorithm.
template<class T , class M >
solver_basic< T, M >	ldlt (const csr< T, M > &a, const solver_option_type &opt=solver_option_type())
template<class T , class M >
solver_basic< T, M >	lu (const csr< T, M > &a, const solver_option_type &opt=solver_option_type())
template<class T , class M >
solver_basic< T, M >	ic0 (const csr< T, M > &a, const solver_option_type &opt=solver_option_type())
template<class T , class M >
solver_basic< T, M >	ilu0 (const csr< T, M > &a, const solver_option_type &opt=solver_option_type())
template<class T , class M >
static csr< T, M >::size_type	nnz_dia_upper (const csr< T, M > &a)
template<class T >
static csr< T, sequential > ::size_type	nnz_ext_upper (const csr< T, sequential > &a)
template<class T >
static csr< T, distributed > ::size_type	nnz_ext_upper (const csr< T, distributed > &a)
template<class T >
static void	csr2mumps_struct (const csr< T, sequential > &a, vector< int > &row, vector< int > &col, bool use_symmetry)
template<class T >
static void	csr2mumps_values (const csr< T, sequential > &a, vector< T > &val, bool use_symmetry)
template<class T >
static void	csr2mumps_struct (const csr< T, distributed > &a, vector< int > &row, vector< int > &col, bool use_symmetry)
template<class T >
static void	csr2mumps_values (const csr< T, distributed > &a, vector< T > &val, bool use_symmetry)
static Epetra_CrsMatrix *	csr2petra (const csr< double, sequential > &a, Epetra_Map *&petra_ownership_ptr)
static Epetra_CrsMatrix *	csr2petra (const csr< double, distributed > &a, Epetra_Map *&petra_ownership_ptr)
template<class T >
idiststream &	operator>> (idiststream &ips, vec< T, sequential > &x)
template<class T , class M >
odiststream &	operator<< (odiststream &ods, const vec< T, M > &x)
template<class T >
idiststream &	operator>> (idiststream &ips, vec< T, distributed > &x)
template<class T , class M >
T	norm2 (const vec< T, M > &x)
template<class T , class M >
T	norm (const vec< T, M > &x)
template<class T , class M >
boost::proto::detail::enable_unary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, vec_domain >::impl< const vec < T, M > & >::result_type > ::type const	operator+ (const vec< T, M > &arg)
template<class Expr >
boost::proto::detail::enable_unary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, vec_domain >::impl< const vec_expr< Expr > & >::result_type >::type const	operator+ (const vec_expr< Expr > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::negate, vec_domain >::impl< const vec < T, M > & >::result_type > ::type const	operator- (const vec< T, M > &arg)
template<class Expr >
boost::proto::detail::enable_unary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::negate, vec_domain >::impl< const vec_expr< Expr > & >::result_type >::type const	operator- (const vec_expr< Expr > &arg)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const int &, const vec< T, M > & >::result_type const > ::type	operator+ (const int &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const T &, const vec< T, M > & >::result_type const > ::type	operator+ (const T &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec < T, M > &, const int & > ::result_type const >::type	operator+ (const vec< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec< T > , T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec < T, M > &, const T & > ::result_type const >::type	operator+ (const vec< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const int &, const vec_expr< Expr > & >::result_type const > ::type	operator+ (const int &l, const vec_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec_expr< Expr > &, const int & > ::result_type const >::type	operator+ (const vec_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const T &, const vec_expr< Expr > & >::result_type const > ::type	operator+ (const T &l, const vec_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec_expr< Expr > &, const T & > ::result_type const >::type	operator+ (const vec_expr< Expr > &l, const T &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T1, M > >, vec< T1, M >, is_vec < vec< T2, M > >, vec< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec < T1, M > &, const vec< T2, M > & >::result_type const > ::type	operator+ (const vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < vec_expr< Expr > >, vec_expr < Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec < T, M > &, const vec_expr < Expr > & >::result_type const >::type	operator+ (const vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< vec< T, M > >, vec < T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec_expr< Expr > &, const vec < T, M > & >::result_type const >::type	operator+ (const vec_expr< Expr > &l, const vec< T, M > &r)
template<class Expr1 , class Expr2 >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr1 > >, vec_expr< Expr1 > , is_vec< vec_expr< Expr2 > >, vec_expr< Expr2 > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, vec_domain >::impl< const vec_expr< Expr1 > &, const vec_expr< Expr2 > & >::result_type const > ::type	operator+ (const vec_expr< Expr1 > &l, const vec_expr< Expr2 > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const int &, const vec< T, M > & >::result_type const > ::type	operator- (const int &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const T &, const vec< T, M > & >::result_type const > ::type	operator- (const T &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec < T, M > &, const int & > ::result_type const >::type	operator- (const vec< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec< T > , T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec < T, M > &, const T & > ::result_type const >::type	operator- (const vec< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const int &, const vec_expr< Expr > & >::result_type const > ::type	operator- (const int &l, const vec_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec_expr< Expr > &, const int & > ::result_type const >::type	operator- (const vec_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const T &, const vec_expr< Expr > & >::result_type const > ::type	operator- (const T &l, const vec_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec_expr< Expr > &, const T & > ::result_type const >::type	operator- (const vec_expr< Expr > &l, const T &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T1, M > >, vec< T1, M >, is_vec < vec< T2, M > >, vec< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec < T1, M > &, const vec< T2, M > & >::result_type const > ::type	operator- (const vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < vec_expr< Expr > >, vec_expr < Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec < T, M > &, const vec_expr < Expr > & >::result_type const >::type	operator- (const vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< vec< T, M > >, vec < T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec_expr< Expr > &, const vec < T, M > & >::result_type const >::type	operator- (const vec_expr< Expr > &l, const vec< T, M > &r)
template<class Expr1 , class Expr2 >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr1 > >, vec_expr< Expr1 > , is_vec< vec_expr< Expr2 > >, vec_expr< Expr2 > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, vec_domain >::impl< const vec_expr< Expr1 > &, const vec_expr< Expr2 > & >::result_type const > ::type	operator- (const vec_expr< Expr1 > &l, const vec_expr< Expr2 > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const int &, const vec< T, M > & >::result_type const > ::type	operator* (const int &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const T &, const vec< T, M > & >::result_type const > ::type	operator* (const T &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec < T, M > &, const int & > ::result_type const >::type	operator* (const vec< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec< T > , T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec < T, M > &, const T & > ::result_type const >::type	operator* (const vec< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const int &, const vec_expr< Expr > & >::result_type const > ::type	operator* (const int &l, const vec_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec_expr< Expr > &, const int & > ::result_type const >::type	operator* (const vec_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const T &, const vec_expr< Expr > & >::result_type const > ::type	operator* (const T &l, const vec_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec_expr< Expr > &, const T & > ::result_type const >::type	operator* (const vec_expr< Expr > &l, const T &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T1, M > >, vec< T1, M >, is_vec < vec< T2, M > >, vec< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec < T1, M > &, const vec< T2, M > & >::result_type const > ::type	operator* (const vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < vec_expr< Expr > >, vec_expr < Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec < T, M > &, const vec_expr < Expr > & >::result_type const >::type	operator* (const vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< vec< T, M > >, vec < T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec_expr< Expr > &, const vec < T, M > & >::result_type const >::type	operator* (const vec_expr< Expr > &l, const vec< T, M > &r)
template<class Expr1 , class Expr2 >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr1 > >, vec_expr< Expr1 > , is_vec< vec_expr< Expr2 > >, vec_expr< Expr2 > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, vec_domain >::impl< const vec_expr< Expr1 > &, const vec_expr< Expr2 > & >::result_type const > ::type	operator* (const vec_expr< Expr1 > &l, const vec_expr< Expr2 > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const int &, const vec< T, M > & >::result_type const > ::type	operator/ (const int &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec< T, M > >, vec< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const T &, const vec< T, M > & >::result_type const > ::type	operator/ (const T &l, const vec< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec < T, M > &, const int & > ::result_type const >::type	operator/ (const vec< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec< T > , T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec < T, M > &, const T & > ::result_type const >::type	operator/ (const vec< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< int > , int, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const int &, const vec_expr< Expr > & >::result_type const > ::type	operator/ (const int &l, const vec_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec_expr< Expr > &, const int & > ::result_type const >::type	operator/ (const vec_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< T >, T, is_vec< vec_expr< Expr > >, vec_expr< Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const T &, const vec_expr< Expr > & >::result_type const > ::type	operator/ (const T &l, const vec_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec_expr< Expr > &, const T & > ::result_type const >::type	operator/ (const vec_expr< Expr > &l, const T &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T1, M > >, vec< T1, M >, is_vec < vec< T2, M > >, vec< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec < T1, M > &, const vec< T2, M > & >::result_type const > ::type	operator/ (const vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec< T, M > >, vec< T, M >, is_vec < vec_expr< Expr > >, vec_expr < Expr >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec < T, M > &, const vec_expr < Expr > & >::result_type const >::type	operator/ (const vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr > >, vec_expr< Expr > , is_vec< vec< T, M > >, vec < T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec_expr< Expr > &, const vec < T, M > & >::result_type const >::type	operator/ (const vec_expr< Expr > &l, const vec< T, M > &r)
template<class Expr1 , class Expr2 >
boost::proto::detail::enable_binary < vec_domain, is_vec< vec_expr < Expr1 > >, vec_expr< Expr1 > , is_vec< vec_expr< Expr2 > >, vec_expr< Expr2 > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, vec_domain >::impl< const vec_expr< Expr1 > &, const vec_expr< Expr2 > & >::result_type const > ::type	operator/ (const vec_expr< Expr1 > &l, const vec_expr< Expr2 > &r)
template<class T , class M >
vec< T, M > &	operator+= (vec< T, M > &l, const int &r)
template<class T , class M >
vec< T, M > &	operator+= (vec< T, M > &l, const T &r)
template<class T1 , class T2 , class M >
vec< T1, M > &	operator+= (vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
vec< T, M > &	operator+= (vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M >
vec< T, M > &	operator-= (vec< T, M > &l, const int &r)
template<class T , class M >
vec< T, M > &	operator-= (vec< T, M > &l, const T &r)
template<class T1 , class T2 , class M >
vec< T1, M > &	operator-= (vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
vec< T, M > &	operator-= (vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M >
vec< T, M > &	operator*= (vec< T, M > &l, const int &r)
template<class T , class M >
vec< T, M > &	operator*= (vec< T, M > &l, const T &r)
template<class T1 , class T2 , class M >
vec< T1, M > &	operator*= (vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
vec< T, M > &	operator*= (vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M >
vec< T, M > &	operator/= (vec< T, M > &l, const int &r)
template<class T , class M >
vec< T, M > &	operator/= (vec< T, M > &l, const T &r)
template<class T1 , class T2 , class M >
vec< T1, M > &	operator/= (vec< T1, M > &l, const vec< T2, M > &r)
template<class T , class M , class Expr >
vec< T, M > &	operator/= (vec< T, M > &l, const vec_expr< Expr > &r)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::abs_, const vec< T, M > & >::type	abs (const vec< T, M > &x)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::abs_, const vec_expr< Expr > & >::type	abs (const vec_expr< Expr > &x)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::fabs_, const vec < T, M > & >::type	fabs (const vec< T, M > &x)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::fabs_, const vec_expr< Expr > & >::type	fabs (const vec_expr< Expr > &x)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::floor_, const vec < T, M > & >::type	floor (const vec< T, M > &x)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::floor_, const vec_expr< Expr > & >::type	floor (const vec_expr< Expr > &x)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::ceil_, const vec < T, M > & >::type	ceil (const vec< T, M > &x)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::ceil_, const vec_expr< Expr > & >::type	ceil (const vec_expr< Expr > &x)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::sqr_, const vec< T, M > & >::type	sqr (const vec< T, M > &x)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::sqr_, const vec_expr< Expr > & >::type	sqr (const vec_expr< Expr > &x)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const int &, const vec< T, M > & >::type	min (const int &x, const vec< T, M > &y)
template<class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const T1 &, const vec< T2, M > & >::type	min (const T1 &x, const vec< T2, M > &y)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec< T, M > &, const int & >::type	min (const vec< T, M > &x, const int &y)
template<class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec < T1, M > &, const T2 & > ::type	min (const vec< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec < T1, M > &, const vec< T2, M > & >::type	min (const vec< T1, M > &x, const vec< T2, M > &y)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const int &, const vec_expr< Expr > & >::type	min (const int &x, const vec_expr< Expr > &y)
template<class T , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const T &, const vec_expr< Expr > & >::type	min (const T &x, const vec_expr< Expr > &y)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec_expr< Expr > &, const int & > ::type	min (const vec_expr< Expr > &x, const int &y)
template<class T , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec_expr< Expr > &, const T & > ::type	min (const vec_expr< Expr > &x, const T &y)
template<class T , class M , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec< T, M > &, const vec_expr< Expr > & >::type	min (const vec< T, M > &x, const vec_expr< Expr > &y)
template<class T , class M , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec_expr< Expr > &, const vec < T, M > & >::type	min (const vec_expr< Expr > &x, const vec< T, M > &y)
template<class Expr1 , class Expr2 >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::min_, const vec_expr< Expr1 > &, const vec_expr< Expr2 > & >::type	min (const vec_expr< Expr1 > &x, const vec_expr< Expr2 > &y)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const int &, const vec< T, M > & >::type	max (const int &x, const vec< T, M > &y)
template<class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const T1 &, const vec< T2, M > & >::type	max (const T1 &x, const vec< T2, M > &y)
template<class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec< T, M > &, const int & >::type	max (const vec< T, M > &x, const int &y)
template<class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec < T1, M > &, const T2 & > ::type	max (const vec< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec < T1, M > &, const vec< T2, M > & >::type	max (const vec< T1, M > &x, const vec< T2, M > &y)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const int &, const vec_expr< Expr > & >::type	max (const int &x, const vec_expr< Expr > &y)
template<class T , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const T &, const vec_expr< Expr > & >::type	max (const T &x, const vec_expr< Expr > &y)
template<class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec_expr< Expr > &, const int & > ::type	max (const vec_expr< Expr > &x, const int &y)
template<class T , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec_expr< Expr > &, const T & > ::type	max (const vec_expr< Expr > &x, const T &y)
template<class T , class M , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec< T, M > &, const vec_expr< Expr > & >::type	max (const vec< T, M > &x, const vec_expr< Expr > &y)
template<class T , class M , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec_expr< Expr > &, const vec < T, M > & >::type	max (const vec_expr< Expr > &x, const vec< T, M > &y)
template<class Expr1 , class Expr2 >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::max_, const vec_expr< Expr1 > &, const vec_expr< Expr2 > & >::type	max (const vec_expr< Expr1 > &x, const vec_expr< Expr2 > &y)
template<class Function , class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose_< Function > , const vec< T, M > & >::type	compose (const Function &f, const vec< T, M > &x)
template<class Function , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose_< Function > , const vec_expr< Expr > & >::type	compose (const Function &f, const vec_expr< Expr > &x)
template<class Function , class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const int &, const vec< T, M > & >::type	compose (const Function &f, const int &x, const vec< T, M > &y)
template<class Function , class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec< T, M > &, const int & >::type	compose (const Function &f, const vec< T, M > &x, const int &y)
template<class Function , class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const T1 &, const vec< T2, M > & >::type	compose (const Function &f, const T1 &x, const vec< T2, M > &y)
template<class Function , class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec< T1, M > &, const T2 & >::type	compose (const Function &f, const vec< T1, M > &x, const T2 &y)
template<class Function , class T1 , class T2 , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec< T1, M > &, const vec< T2, M > & >::type	compose (const Function &f, const vec< T1, M > &x, const vec< T2, M > &y)
template<class Function , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const int &, const vec_expr< Expr > & >::type	compose (const Function &f, const int &x, const vec_expr< Expr > &y)
template<class Function , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec_expr < Expr > &, const int & > ::type	compose (const Function &f, const vec_expr< Expr > &x, const int &y)
template<class Function , class T , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const T &, const vec_expr< Expr > & >::type	compose (const Function &f, const T &x, const vec_expr< Expr > &y)
template<class Function , class T , class Expr >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec_expr < Expr > &, const T & >::type	compose (const Function &f, const vec_expr< Expr > &x, const T &y)
template<class Function , class Expr , class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec< T, M > &, const vec_expr< Expr > & >::type	compose (const Function &f, const vec< T, M > &x, const vec_expr< Expr > &y)
template<class Function , class Expr , class T , class M >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec_expr < Expr > &, const vec< T, M > & >::type	compose (const Function &f, const vec_expr< Expr > &x, const vec< T, M > &y)
template<class Function , class Expr1 , class Expr2 >
boost::proto::result_of::make_expr < boost::proto::tag::function, vec_domain, const vec_detail::compose2_ < Function >, const vec_expr < Expr1 > &, const vec_expr < Expr2 > & >::type	compose (const Function &f, const vec_expr< Expr1 > &x, const vec_expr< Expr2 > &y)
template<class T , class M >
T	dot (const vec< T, M > &x, const int &y)
template<class T , class M >
T	dot (const int &x, const vec< T, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dot (const vec< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dot (const T1 &x, const vec< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dot (const vec< T1, M > &x, const vec< T2, M > &y)
template<class Expr >
vec_expr< Expr >::value_type	dot (const vec_expr< Expr > &x, const int &y)
template<class Expr >
vec_expr< Expr >::value_type	dot (const int &x, const vec_expr< Expr > &y)
template<class T , class Expr >
promote< T, typename vec_expr < Expr >::value_type >::type	dot (const vec_expr< Expr > &x, const T &y)
template<class T , class Expr >
promote< T, typename vec_expr < Expr >::value_type >::type	dot (const T &x, const vec_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename vec_expr < Expr >::value_type >::type	dot (const vec< T, M > &x, const vec_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename vec_expr < Expr >::value_type >::type	dot (const vec_expr< Expr > &x, const vec< T, M > &y)
template<class Expr1 , class Expr2 >
promote< typename vec_expr < Expr1 >::value_type, typename vec_expr< Expr2 > ::value_type >::type	dot (const vec_expr< Expr1 > &x, const vec_expr< Expr2 > &y)
std::istream &	operator>> (std::istream &is, geo_element_indirect &x)
std::ostream &	operator<< (std::ostream &os, const geo_element_indirect &x)
template<class T , class M >
bool	point_belongs_to_e (const array< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
template<class T , class M >
bool	point_belongs_to_t (const array< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
template<class T , class M >
bool	point_belongs_to_q (const array< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
template<class T , class M >
bool	point_belongs_to_T (const array< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
template<class T , class M >
bool	point_belongs_to_H (const array< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
template<class T , class M >
bool	point_belongs_to_P (const array< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
char	skip_blancs_and_tabs (istream &is)
istream &	operator>> (istream &is, geo_element &K)
ostream &	operator<< (ostream &os, const geo_element &K)
template<class T , class A >
idiststream &	operator>> (idiststream &ips, hack_array< T, sequential, A > &x)
template<class T , class A >
odiststream &	operator<< (odiststream &ops, const hack_array< T, sequential, A > &x)
template<class T , class A >
idiststream &	operator>> (idiststream &ips, hack_array< T, distributed, A > &x)
template<class T , class A >
odiststream &	operator<< (odiststream &ops, const hack_array< T, distributed, A > &x)
template<class T >
point_basic< T >	operator* (int a, const point_basic< T > &u)
template<class T >
point_basic< T >	operator* (const T &a, const point_basic< T > &u)
template<class T >
point_basic< T >	vect (const point_basic< T > &v, const point_basic< T > &w)
template<class T >
T	dot (const point_basic< T > &x, const point_basic< T > &y)
template<class T >
T	norm2 (const point_basic< T > &x)
template<class T >
T	norm (const point_basic< T > &x)
template<class T >
T	dist2 (const point_basic< T > &x, const point_basic< T > &y)
template<class T >
T	dist (const point_basic< T > &x, const point_basic< T > &y)
template<class T >
T	dist_infty (const point_basic< T > &x, const point_basic< T > &y)
template<class T >
T	vect2d (const point_basic< T > &v, const point_basic< T > &w)
template<class T >
T	mixt (const point_basic< T > &u, const point_basic< T > &v, const point_basic< T > &w)
template<class T >
int	sign_orient2d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
template<class T >
int	sign_orient3d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c, const point_basic< T > &d)
template<class T >
T	orient2d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
template<class T >
T	orient3d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c, const point_basic< T > &d)
template<class T >
std::string	ptos (const point_basic< T > &x, int d=3)
template<class T , size_t d>
bool	lexicographically_less (const point_basic< T > &a, const point_basic< T > &b)
template<class T >
std::istream &	operator>> (std::istream &s, point_basic< T > &p)
template<class T >
std::ostream &	operator<< (std::ostream &s, const point_basic< T > &p)
	def_point_function (sqr) def_point_function(sqrt) def_point_function(log) def_point_function(log10) def_point_function(exp) template< class T1
class T2 inline point_basic< T1 >	operator/ (const T2 &a, const point_basic< T1 > &x)
template<class T >
static T	inexact_orient2d (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b)
template<class T >
static T	inexact_orient3d (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
template<class T >
ostream &	operator<< (ostream &out, const quadrature_on_geo< T > &x)
template<class T >
ostream &	operator<< (ostream &out, const quadrature_rep< T > &x)
Float	measure (reference_element hat_K)
static reference_element_H::size_type	H_ilat2loc_inod (size_type order, const point_basic< size_type > &ilat)
template<class T >
static T	hypot2 (const T &x, const T &y)
template<class T >
static void	tred2 (tensor_basic< T > &V, point_basic< T > &d, point_basic< T > &e)
template<class T >
static void	tql2 (tensor_basic< T > &V, point_basic< T > &d, point_basic< T > &e)
template<class T >
void	eigen_decomposition (const tensor_basic< T > &A, tensor_basic< T > &V, point_basic< T > &d)
template<class T >
const T	MIN (const T &a, const T &b)
template<class T >
const T	MAX (const T &a, const T &b)
template<class T >
const T	SIGN (const T &a, const T &b)
template<class T >
const T	SQR (const T a)
template<class T >
T	pythag (const T &a, const T &b)
template<class Matrix1 , class Matrix2 , class Vector , class T , class Size >
void	svdcmp (Matrix1 &a, Vector &w, Matrix2 &v, Size anrow, Size ancol, T dummy)
template<class T >
tensor_basic< T >	operator- (const tensor_basic< T > &a)
template<class T >
tensor_basic< T >	operator+ (const tensor_basic< T > &a, const tensor_basic< T > &b)
template<class T >
tensor_basic< T >	operator- (const tensor_basic< T > &a, const tensor_basic< T > &b)
template<class T >
tensor_basic< T >	operator* (const T &k, const tensor_basic< T > &a)
template<class T >
point_basic< T >	operator* (const tensor_basic< T > &a, const point_basic< T > &x)
template<class T >
point_basic< T >	operator* (const point_basic< T > &x, const tensor_basic< T > &a)
template<class T >
tensor_basic< T >	trans (const tensor_basic< T > &a, size_t d)
template<class T >
tensor_basic< T >	inv (const tensor_basic< T > &a, size_t d)
template<class T >
void	prod (const tensor_basic< T > &a, const tensor_basic< T > &b, tensor_basic< T > &result, size_t di, size_t dj, size_t dk)
template<class T >
tensor_basic< T >	operator* (const tensor_basic< T > &a, const tensor_basic< T > &b)
template<class T >
T	dotdot (const tensor_basic< T > &a, const tensor_basic< T > &b)
template<class T >
void	cumul_otimes (tensor_basic< T > &t, const point_basic< T > &a, const point_basic< T > &b, size_t na, size_t nb)
template<class T >
bool	invert_3x3 (const tensor_basic< T > &A, tensor_basic< T > &result)
template<class T >
static point_basic< T >	eig3x3 (const tensor_basic< T > &a, tensor_basic< T > &q)
template<class T >
static point_basic< T >	eig2x2 (const tensor_basic< T > &a, tensor_basic< T > &q)
template<class T >
std::istream &	operator>> (std::istream &in, tensor_basic< T > &a)
template<class T >
std::ostream &	operator<< (std::ostream &out, const tensor_basic< T > &a)
template<class T >
tensor_basic< T >	otimes (const point_basic< T > &a, const point_basic< T > &b, size_t na=3)
template<class T >
void	cumul_otimes (tensor_basic< T > &t, const point_basic< T > &a, const point_basic< T > &b, size_t na=3)
template<class T >
tensor_basic< T >	operator* (int k, const tensor_basic< T > &a)
template<class T >
tensor_basic< T >	operator* (const tensor_basic< T > &a, int k)
template<class T >
tensor_basic< T >	operator* (const tensor_basic< T > &a, const T &k)
template<class T >
tensor_basic< T >	operator/ (const tensor_basic< T > &a, int k)
template<class T >
tensor_basic< T >	operator/ (const tensor_basic< T > &a, const T &k)
template<class T >
T	determinant (const tensor_basic< T > &A, size_t d)
template<class T >
tensor_basic< T >	diag (const point_basic< T > &d)
template<class T >
tensor_basic< T >	identity (size_t d)
template<class T >
tensor_basic< T >	dyadic (const point_basic< T > &u, const point_basic< T > &v, size_t d)
template<class T >
void	lu (tiny_matrix< T > &a, tiny_vector< size_t > &piv)
template<class T >
void	solve (tiny_matrix< T > &a, tiny_vector< size_t > &piv, const tiny_vector< T > &b, tiny_vector< T > &x)
template<class T >
void	invert (tiny_matrix< T > &a, tiny_matrix< T > &inv_a)
template<class T >
void	put (std::ostream &out, std::string name, const tiny_matrix< T > &a)
template<class T >
void	trans (const tiny_matrix< T > &a, tiny_matrix< T > &b)
template<class T >
tiny_matrix< T >	operator* (const tiny_matrix< T > &a, const tiny_matrix< T > &b)
template<class T >
tiny_vector< T >	operator* (const tiny_matrix< T > &a, const tiny_vector< T > &u)
template<class T , class M >
geo_basic< T, M >	adapt_gmsh (const field_basic< T, M > &uh, const adapt_option_type &opts)
template<class T , class M >
geo_basic< T, M >	adapt_bamg (const field_basic< T, M > &uh, const adapt_option_type &opts)
template<class T , class M >
field_basic< T, M >	proj (const field_basic< T, M > &uh, const std::string &approx="P1")
template<class T , class M >
field_basic< T, M >	smooth (const field_basic< T, M > &uh, size_t n=1)
template<class T , class M >
field_basic< T, M >	hessian (const field_basic< T, M > &uh)
template<class T , class M >
field_basic< T, M >	hessian_criterion (const field_basic< T, M > &uh0, const adapt_option_type &opts)
template<class T , class M >
geo_basic< T, M >	adapt (const field_basic< T, M > &uh, const adapt_option_type &opts)
template<class T , class M >
geo_basic< T, M >	level_set_internal (const field_basic< T, M > &, const level_set_option_type &, std::vector< size_t > &, array< size_t, M > &)
template<class T >
static bool	band_is_zero (const T &x)
template<class T , class M >
static geo_element::size_type	build_vertex_connex_component (const geo_basic< T, M > &band, const std::vector< geo_element::size_type > &zero_iv_list, const std::vector< geo_element::size_type > &isolated_ie_list)
template<class T >
void	put_header (odiststream &out, const branch_basic< T, sequential > &b)
template<class T >
void	put_header (odiststream &out, const branch_basic< T, distributed > &b)
template<class T , class M >
idiststream &	operator>> (idiststream &in, branch_basic< T, M > &b)
template<class T >
void	put_event (odiststream &out, const branch_basic< T, sequential > &b)
template<class T >
void	put_event (odiststream &out, const branch_basic< T, distributed > &b)
template<class T , class M >
odiststream &	operator<< (odiststream &out, const branch_basic< T, M > &b)
template<class T >
void	put_finalize (odiststream &out, const branch_basic< T, sequential > &b)
template<class T >
void	put_finalize (odiststream &out, const branch_basic< T, distributed > &b)
template<class T , class M >
odiststream &	operator<< (odiststream &os, __iobranch< T, M > m)
template<class T , class M >
idiststream &	operator>> (idiststream &is, __iobranch< T, M > m)
template<class T >
void	put_header_gnuplot (odiststream &ops, const branch_basic< T, sequential > &b)
template<class T >
void	put_event_gnuplot (odiststream &ops, const branch_basic< T, sequential > &b)
template<class T >
void	put_finalize_gnuplot (odiststream &ops, const branch_basic< T, sequential > &b)
template void	put_header_gnuplot (odiststream &, const branch_basic< Float, sequential > &)
template void	put_event_gnuplot (odiststream &, const branch_basic< Float, sequential > &)
template void	put_finalize_gnuplot (odiststream &, const branch_basic< Float, sequential > &)
template<class T >
odiststream &	field_put_vtk (odiststream &, const field_basic< T, sequential > &, std::string, bool)
template<class T >
void	put_header_paraview (odiststream &out, const branch_basic< T, sequential > &)
template<class T >
void	put_event_paraview (odiststream &ods, const branch_basic< T, sequential > &b)
template<class T >
void	put_finalize_paraview (odiststream &out, const branch_basic< T, sequential > &b)
template void	put_header_paraview (odiststream &, const branch_basic< Float, sequential > &)
template void	put_event_paraview (odiststream &, const branch_basic< Float, sequential > &)
template void	put_finalize_paraview (odiststream &, const branch_basic< Float, sequential > &)
template<class T , class M >
void	interpolate_pass1_symbolic (const geo_basic< T, M > &omega, const array< point_basic< T >, M > &x, const array< geo_element::size_type, M > &ix2dis_ie, array< index_set, M > &ie2dis_ix, array< point_basic< T >, M > &hat_y)
template<class T , class M >
void	interpolate_pass2_valued (const field_basic< T, M > &uh, const array< point_basic< T >, M > &x, const array< index_set, M > &ie2dis_ix, const array< point_basic< T >, M > &hat_y, array< T, M > &ux)
template<class T , class M >
void	riesz_pass1_symbolic (const space_basic< T, M > &Xh, const field_basic< T, M > &dh, quadrature_option_type &qopt, quadrature< T > &quad, basis_on_pointset< T > &piola_on_quad, array< index_set, M > &ie2dis_ix, array< point_basic< T >, M > &hat_y, array< point_basic< T >, M > &yq)
template<class T , class M >
field_basic< T, M >	riesz_pass2_valued (const space_basic< T, M > &Xh, const field_basic< T, M > &uh, const quadrature< T > &quad, const basis_on_pointset< T > &piola_on_quad, const array< index_set, M > &ie2dis_ix, const array< point_basic< T >, M > &hat_y, const array< point_basic< T >, M > &yq)
template<class T , class M >
field_basic< T, M >	riesz (const space_basic< T, M > &Xh, const field_o_characteristic< T, M > &f, quadrature_option_type qopt)
template<class T , class M >
field_o_characteristic< T, M >	compose (const field_basic< T, M > &uh, characteristic_basic< T, M > &X)@endcode
template<class Problem , class Preconditioner , class Field , class Real , class Size >
int	damped_newton (Problem P, Preconditioner T, Field &u, Real &tol, Size &max_iter, odiststream *p_derr=0)
template<class Problem , class Field , class Real , class Size >
int	damped_newton (Problem P, Field &u, Real &tol, Size &max_iter, odiststream *p_derr=0)
void	build_set_that_contains_S (const geo_element &S, const std::vector< index_set > &ball, index_set &contains_S)
template<class T , class M >
static void	get_field_recursive (idiststream &ids, vec< T, M > &u_io, const space_constitution< T, M > &constit, distributor::size_type &comp_start_dis_idof, distributor::size_type &comp_start_ios_idof, bool read_header=false)
template<class T , class M >
static void	put_field_recursive (odiststream &ods, const field_basic< T, M > &uh, const space_constitution< T, M > &constit, distributor::size_type &comp_start_idof, distributor::size_type &comp_start_dis_idof, bool write_header=false)
template<class T >
odiststream &	visu_gnuplot (odiststream &, const field_basic< T, sequential > &)
template<class T >
odiststream &	visu_vtk_mayavi (odiststream &, const field_basic< T, sequential > &)
template<class T >
odiststream &	field_put_gmsh (odiststream &, const field_basic< T, sequential > &)
template<class T >
odiststream &	field_put_gmsh_pos (odiststream &, const field_basic< T, sequential > &)
template<class T >
odiststream &	field_put_bamg_bb (odiststream &, const field_basic< T, sequential > &)
template<class T , class M >
idiststream &	operator>> (odiststream &ips, field_basic< T, M > &u)
template<class T , class M >
odiststream &	operator<< (odiststream &ops, const field_basic< T, M > &uh)
template<class T , class M >
idiststream &	operator>> (idiststream &ips, field_basic< T, M > &uh)
template<class T , class M , class Function , class FieldElement >
void	field_assembly (const geo_basic< T, M > &domain, const FieldElement &field_e, const Function &fct, field_basic< T, M > &lh)
template<class T , class M >
odiststream &	operator<< (odiststream &ods, const field_component< T, M > &uh_comp)
template<class T , class M >
odiststream &	operator<< (odiststream &ods, const field_component_const< T, M > &uh_comp)
template<class T , class M , class BasisOnPointset >
T	field_evaluate (const field_basic< T, M > &uh, const BasisOnPointset &basis_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q)
template<class T , class M , class BasisOnPointset >
point_basic< T >	vector_field_evaluate (const field_basic< T, M > &uh, const BasisOnPointset &basis_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q)
template<class T , class M , class BasisOnPointset >
tensor_basic< T >	tensor_field_evaluate (const field_basic< T, M > &uh, const BasisOnPointset &basis_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q)
template<class T , class M >
void	generic_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, T &value)
template<class T , class M >
void	generic_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, point_basic< T > &value)
template<class T , class M >
void	generic_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, tensor_basic< T > &value)
template<class T , class M , class BasisOnPointset >
T	field_component_evaluate (const field_basic< T, M > &uh, const BasisOnPointset &basis_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q, size_t i_comp)
template<class Expr >
odiststream &	operator<< (odiststream &ops, const field_expr< Expr > &uh)
template<class Expr >
form_basic< typename field_expr< Expr > ::scalar_type, rheo_default_memory_model >	diag (const field_expr< Expr > &expr)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, field_domain >::impl< const field_basic< T, M > & >::result_type >::type const	operator+ (const field_basic< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, field_domain >::impl< const field_indirect< T, M > & >::result_type >::type const	operator+ (const field_indirect< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, field_domain >::impl< const field_indirect_const< T, M > & >::result_type >::type const	operator+ (const field_indirect_const< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, field_domain >::impl< const field_component< T, M > & >::result_type >::type const	operator+ (const field_component< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, field_domain >::impl< const field_component_const< T, M > & >::result_type >::type const	operator+ (const field_component_const< T, M > &arg)
template<class Expr >
boost::proto::detail::enable_unary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::unary_plus, field_domain >::impl< const field_expr< Expr > & >::result_type >::type const	operator+ (const field_expr< Expr > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::negate, field_domain >::impl< const field_basic< T, M > & >::result_type >::type const	operator- (const field_basic< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::negate, field_domain >::impl< const field_indirect< T, M > & >::result_type >::type const	operator- (const field_indirect< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::negate, field_domain >::impl< const field_indirect_const< T, M > & >::result_type >::type const	operator- (const field_indirect_const< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::negate, field_domain >::impl< const field_component< T, M > & >::result_type >::type const	operator- (const field_component< T, M > &arg)
template<class T , class M >
boost::proto::detail::enable_unary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::negate, field_domain >::impl< const field_component_const< T, M > & >::result_type >::type const	operator- (const field_component_const< T, M > &arg)
template<class Expr >
boost::proto::detail::enable_unary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::negate, field_domain >::impl< const field_expr< Expr > & >::result_type >::type const	operator- (const field_expr< Expr > &arg)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_basic < T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const int &, const field_basic< T, M > & >::result_type const > ::type	operator+ (const int &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const T &, const field_basic< T, M > & >::result_type const > ::type	operator+ (const T &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const int &, const field_indirect< T, M > & >::result_type const > ::type	operator+ (const int &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_indirect < T, M > >, field_indirect< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const T &, const field_indirect< T, M > & >::result_type const > ::type	operator+ (const T &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const int &, const field_indirect_const< T, M > & >::result_type const > ::type	operator+ (const int &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const T &, const field_indirect_const < T, M > & >::result_type const >::type	operator+ (const T &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const int &, const field_component < T, M > & >::result_type const >::type	operator+ (const int &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_component < T, M > >, field_component< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const T &, const field_component< T, M > & >::result_type const > ::type	operator+ (const T &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const int &, const field_component_const< T, M > & >::result_type const > ::type	operator+ (const int &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const T &, const field_component_const < T, M > & >::result_type const >::type	operator+ (const T &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T, M > &, const int & >::result_type const > ::type	operator+ (const field_basic< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T, M > &, const T & > ::result_type const >::type	operator+ (const field_basic< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T, M > &, const int & >::result_type const >::type	operator+ (const field_indirect< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T, M > &, const T & >::result_type const >::type	operator+ (const field_indirect< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T, M > &, const int & >::result_type const >::type	operator+ (const field_indirect_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T, M > &, const T & >::result_type const >::type	operator+ (const field_indirect_const< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T, M > &, const int & >::result_type const >::type	operator+ (const field_component< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T, M > &, const T & >::result_type const >::type	operator+ (const field_component< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T, M > &, const int & >::result_type const >::type	operator+ (const field_component_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T, M > &, const T & >::result_type const >::type	operator+ (const field_component_const< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const int &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const int &l, const field_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const int & >::result_type const > ::type	operator+ (const field_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const T &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const T &l, const field_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const T & > ::result_type const >::type	operator+ (const field_expr< Expr > &l, const T &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator+ (const field_basic< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field< field_indirect< T2, M > >, field_indirect< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator+ (const field_basic< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T1, M > &, const field_indirect_const< T2, M > & >::result_type const > ::type	operator+ (const field_basic< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator+ (const field_basic< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator+ (const field_basic< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator+ (const field_indirect< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field< field_indirect< T2, M > >, field_indirect< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator+ (const field_indirect< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator+ (const field_indirect< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator+ (const field_indirect< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator+ (const field_indirect< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator+ (const field_indirect_const< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field< field_indirect < T2, M > >, field_indirect < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator+ (const field_indirect_const< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator+ (const field_indirect_const< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator+ (const field_indirect_const< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator+ (const field_indirect_const< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator+ (const field_component< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field< field_indirect< T2, M > >, field_indirect< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator+ (const field_component< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator+ (const field_component< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator+ (const field_component< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator+ (const field_component< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator+ (const field_component_const< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field< field_indirect < T2, M > >, field_indirect < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator+ (const field_component_const< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator+ (const field_component_const< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator+ (const field_component_const< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator+ (const field_component_const< T1, M > &l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_basic< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const field_basic< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const field_basic< T, M > & >::result_type const > ::type	operator+ (const field_expr< Expr > &l, const field_basic< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const field_indirect< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const field_indirect< T, M > & >::result_type const > ::type	operator+ (const field_expr< Expr > &l, const field_indirect< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_indirect_const< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const field_indirect_const< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const field_indirect_const< T, M > & >::result_type const > ::type	operator+ (const field_expr< Expr > &l, const field_indirect_const< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const field_component< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const field_component< T, M > & >::result_type const > ::type	operator+ (const field_expr< Expr > &l, const field_component< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_component_const< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator+ (const field_component_const< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr > &, const field_component_const< T, M > & >::result_type const > ::type	operator+ (const field_expr< Expr > &l, const field_component_const< T, M > &r)
template<class Expr1 , class Expr2 >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr1 > >, field_expr< Expr1 > , is_field< field_expr< Expr2 > >, field_expr< Expr2 > , typename boost::proto::functional::make_expr < boost::proto::tag::plus, field_domain >::impl< const field_expr< Expr1 > &, const field_expr< Expr2 > & >::result_type const > ::type	operator+ (const field_expr< Expr1 > &l, const field_expr< Expr2 > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_basic < T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const int &, const field_basic< T, M > & >::result_type const > ::type	operator- (const int &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const T &, const field_basic< T, M > & >::result_type const > ::type	operator- (const T &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const int &, const field_indirect< T, M > & >::result_type const > ::type	operator- (const int &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_indirect < T, M > >, field_indirect< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const T &, const field_indirect< T, M > & >::result_type const > ::type	operator- (const T &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const int &, const field_indirect_const< T, M > & >::result_type const > ::type	operator- (const int &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const T &, const field_indirect_const < T, M > & >::result_type const >::type	operator- (const T &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const int &, const field_component < T, M > & >::result_type const >::type	operator- (const int &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_component < T, M > >, field_component< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const T &, const field_component< T, M > & >::result_type const > ::type	operator- (const T &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const int &, const field_component_const< T, M > & >::result_type const > ::type	operator- (const int &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const T &, const field_component_const < T, M > & >::result_type const >::type	operator- (const T &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T, M > &, const int & >::result_type const > ::type	operator- (const field_basic< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T, M > &, const T & > ::result_type const >::type	operator- (const field_basic< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T, M > &, const int & >::result_type const >::type	operator- (const field_indirect< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T, M > &, const T & >::result_type const >::type	operator- (const field_indirect< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T, M > &, const int & >::result_type const >::type	operator- (const field_indirect_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T, M > &, const T & >::result_type const >::type	operator- (const field_indirect_const< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T, M > &, const int & >::result_type const >::type	operator- (const field_component< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T, M > &, const T & >::result_type const >::type	operator- (const field_component< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T, M > &, const int & >::result_type const >::type	operator- (const field_component_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T, M > &, const T & >::result_type const >::type	operator- (const field_component_const< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const int &, const field_expr< Expr > & >::result_type const > ::type	operator- (const int &l, const field_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const int & >::result_type const > ::type	operator- (const field_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const T &, const field_expr< Expr > & >::result_type const > ::type	operator- (const T &l, const field_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const T & > ::result_type const >::type	operator- (const field_expr< Expr > &l, const T &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator- (const field_basic< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field< field_indirect< T2, M > >, field_indirect< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator- (const field_basic< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T1, M > &, const field_indirect_const< T2, M > & >::result_type const > ::type	operator- (const field_basic< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator- (const field_basic< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T1, M > >, field_basic< T1, M > , is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator- (const field_basic< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator- (const field_indirect< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field< field_indirect< T2, M > >, field_indirect< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator- (const field_indirect< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator- (const field_indirect< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator- (const field_indirect< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T1, M > >, field_indirect< T1, M > , is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator- (const field_indirect< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator- (const field_indirect_const< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field< field_indirect < T2, M > >, field_indirect < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator- (const field_indirect_const< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator- (const field_indirect_const< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator- (const field_indirect_const< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T1, M > >, field_indirect_const< T1, M >, is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator- (const field_indirect_const< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator- (const field_component< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field< field_indirect< T2, M > >, field_indirect< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator- (const field_component< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator- (const field_component< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator- (const field_component< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T1, M > >, field_component< T1, M > , is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator- (const field_component< T1, M > &l, const field_component_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field< field_basic< T2, M > >, field_basic< T2, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T1, M > &, const field_basic< T2, M > & >::result_type const > ::type	operator- (const field_component_const< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field< field_indirect < T2, M > >, field_indirect < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T1, M > &, const field_indirect< T2, M > & >::result_type const > ::type	operator- (const field_component_const< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field < field_indirect_const< T2, M > >, field_indirect_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T1, M > &, const field_indirect_const < T2, M > & >::result_type const >::type	operator- (const field_component_const< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field< field_component < T2, M > >, field_component < T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T1, M > &, const field_component< T2, M > & >::result_type const > ::type	operator- (const field_component_const< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T1, M > >, field_component_const< T1, M >, is_field < field_component_const< T2, M > >, field_component_const< T2, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T1, M > &, const field_component_const< T2, M > & >::result_type const > ::type	operator- (const field_component_const< T1, M > &l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_basic< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator- (const field_basic< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const field_basic< T, M > & >::result_type const > ::type	operator- (const field_expr< Expr > &l, const field_basic< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator- (const field_indirect< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const field_indirect< T, M > & >::result_type const > ::type	operator- (const field_expr< Expr > &l, const field_indirect< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_indirect_const< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator- (const field_indirect_const< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const field_indirect_const< T, M > & >::result_type const > ::type	operator- (const field_expr< Expr > &l, const field_indirect_const< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< field_expr< Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator- (const field_component< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const field_component< T, M > & >::result_type const > ::type	operator- (const field_expr< Expr > &l, const field_component< T, M > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_component_const< T, M > &, const field_expr< Expr > & >::result_type const > ::type	operator- (const field_component_const< T, M > &l, const field_expr< Expr > &r)
template<class T , class M , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr > &, const field_component_const< T, M > & >::result_type const > ::type	operator- (const field_expr< Expr > &l, const field_component_const< T, M > &r)
template<class Expr1 , class Expr2 >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr1 > >, field_expr< Expr1 > , is_field< field_expr< Expr2 > >, field_expr< Expr2 > , typename boost::proto::functional::make_expr < boost::proto::tag::minus, field_domain >::impl< const field_expr< Expr1 > &, const field_expr< Expr2 > & >::result_type const > ::type	operator- (const field_expr< Expr1 > &l, const field_expr< Expr2 > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_basic < T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const int &, const field_basic< T, M > & >::result_type const > ::type	operator* (const int &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const T &, const field_basic< T, M > & >::result_type const > ::type	operator* (const T &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const int &, const field_indirect< T, M > & >::result_type const > ::type	operator* (const int &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_indirect < T, M > >, field_indirect< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const T &, const field_indirect< T, M > & >::result_type const > ::type	operator* (const T &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const int &, const field_indirect_const< T, M > & >::result_type const > ::type	operator* (const int &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const T &, const field_indirect_const < T, M > & >::result_type const >::type	operator* (const T &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const int &, const field_component < T, M > & >::result_type const >::type	operator* (const int &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_component < T, M > >, field_component< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const T &, const field_component< T, M > & >::result_type const > ::type	operator* (const T &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const int &, const field_component_const< T, M > & >::result_type const > ::type	operator* (const int &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const T &, const field_component_const < T, M > & >::result_type const >::type	operator* (const T &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_basic< T, M > &, const int & >::result_type const > ::type	operator* (const field_basic< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_basic< T, M > &, const T & > ::result_type const >::type	operator* (const field_basic< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_indirect< T, M > &, const int & >::result_type const >::type	operator* (const field_indirect< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_indirect< T, M > &, const T & >::result_type const >::type	operator* (const field_indirect< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_indirect_const< T, M > &, const int & >::result_type const >::type	operator* (const field_indirect_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_indirect_const< T, M > &, const T & >::result_type const >::type	operator* (const field_indirect_const< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_component< T, M > &, const int & >::result_type const >::type	operator* (const field_component< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_component< T, M > &, const T & >::result_type const >::type	operator* (const field_component< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_component_const< T, M > &, const int & >::result_type const >::type	operator* (const field_component_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_component_const< T, M > &, const T & >::result_type const >::type	operator* (const field_component_const< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const int &, const field_expr< Expr > & >::result_type const > ::type	operator* (const int &l, const field_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_expr< Expr > &, const int & >::result_type const > ::type	operator* (const field_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const T &, const field_expr< Expr > & >::result_type const > ::type	operator* (const T &l, const field_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::multiplies, field_domain >::impl< const field_expr< Expr > &, const T & > ::result_type const >::type	operator* (const field_expr< Expr > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_basic < T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const int &, const field_basic< T, M > & >::result_type const > ::type	operator/ (const int &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_basic< T, M > >, field_basic< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const T &, const field_basic< T, M > & >::result_type const > ::type	operator/ (const T &l, const field_basic< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect< T, M > >, field_indirect< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const int &, const field_indirect< T, M > & >::result_type const > ::type	operator/ (const int &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_indirect < T, M > >, field_indirect< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const T &, const field_indirect< T, M > & >::result_type const > ::type	operator/ (const T &l, const field_indirect< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const int &, const field_indirect_const< T, M > & >::result_type const > ::type	operator/ (const int &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const T &, const field_indirect_const < T, M > & >::result_type const >::type	operator/ (const T &l, const field_indirect_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component< T, M > >, field_component< T, M > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const int &, const field_component < T, M > & >::result_type const >::type	operator/ (const int &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_component < T, M > >, field_component< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const T &, const field_component< T, M > & >::result_type const > ::type	operator/ (const T &l, const field_component< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const int &, const field_component_const< T, M > & >::result_type const > ::type	operator/ (const int &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field < field_component_const< T, M > >, field_component_const< T, M >, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const T &, const field_component_const < T, M > & >::result_type const >::type	operator/ (const T &l, const field_component_const< T, M > &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_basic< T, M > &, const int & >::result_type const > ::type	operator/ (const field_basic< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_basic< T, M > >, field_basic< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_basic< T, M > &, const T & > ::result_type const >::type	operator/ (const field_basic< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_indirect< T, M > &, const int & >::result_type const >::type	operator/ (const field_indirect< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect< T, M > >, field_indirect< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_indirect< T, M > &, const T & >::result_type const >::type	operator/ (const field_indirect< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_indirect_const< T, M > &, const int & >::result_type const >::type	operator/ (const field_indirect_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_indirect_const< T, M > >, field_indirect_const< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_indirect_const< T, M > &, const T & >::result_type const >::type	operator/ (const field_indirect_const< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_component< T, M > &, const int & >::result_type const >::type	operator/ (const field_component< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component< T, M > >, field_component< T, M > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_component< T, M > &, const T & >::result_type const >::type	operator/ (const field_component< T, M > &l, const T &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_component_const< T, M > &, const int & >::result_type const >::type	operator/ (const field_component_const< T, M > &l, const int &r)
template<class T , class M >
boost::proto::detail::enable_binary < field_domain, is_field < field_component_const< T, M > >, field_component_const< T, M >, is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_component_const< T, M > &, const T & >::result_type const >::type	operator/ (const field_component_const< T, M > &l, const T &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< int > , int, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const int &, const field_expr< Expr > & >::result_type const > ::type	operator/ (const int &l, const field_expr< Expr > &r)
template<class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< int >, int, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_expr< Expr > &, const int & >::result_type const > ::type	operator/ (const field_expr< Expr > &l, const int &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field< T > , T, is_field< field_expr < Expr > >, field_expr< Expr > , typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const T &, const field_expr< Expr > & >::result_type const > ::type	operator/ (const T &l, const field_expr< Expr > &r)
template<class T , class Expr >
boost::proto::detail::enable_binary < field_domain, is_field < field_expr< Expr > >, field_expr< Expr > , is_field< T >, T, typename boost::proto::functional::make_expr < boost::proto::tag::divides, field_domain >::impl< const field_expr< Expr > &, const T & > ::result_type const >::type	operator/ (const field_expr< Expr > &l, const T &r)
template<class T , class M >
field_basic< T, M > &	operator+= (field_basic< T, M > &l, const int &r)
template<class T , class M >
field_basic< T, M > &	operator+= (field_basic< T, M > &l, const T &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator+= (field_basic< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator+= (field_basic< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator+= (field_basic< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator+= (field_basic< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator+= (field_basic< T1, M > &l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
field_basic< T, M > &	operator+= (field_basic< T, M > &l, const field_expr< Expr > &r)
template<class T , class M >
field_indirect< T, M >	operator+= (field_indirect< T, M > l, const int &r)
template<class T , class M >
field_indirect< T, M >	operator+= (field_indirect< T, M > l, const T &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator+= (field_indirect< T1, M > l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator+= (field_indirect< T1, M > l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator+= (field_indirect< T1, M > l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator+= (field_indirect< T1, M > l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator+= (field_indirect< T1, M > l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
field_indirect< T, M >	operator+= (field_indirect< T, M > l, const field_expr< Expr > &r)
template<class T , class M >
field_component< T, M >	operator+= (field_component< T, M > l, const int &r)
template<class T , class M >
field_component< T, M >	operator+= (field_component< T, M > l, const T &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator+= (field_component< T1, M > l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator+= (field_component< T1, M > l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator+= (field_component< T1, M > l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator+= (field_component< T1, M > l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator+= (field_component< T1, M > l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
field_component< T, M >	operator+= (field_component< T, M > l, const field_expr< Expr > &r)
template<class T , class M >
field_basic< T, M > &	operator-= (field_basic< T, M > &l, const int &r)
template<class T , class M >
field_basic< T, M > &	operator-= (field_basic< T, M > &l, const T &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator-= (field_basic< T1, M > &l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator-= (field_basic< T1, M > &l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator-= (field_basic< T1, M > &l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator-= (field_basic< T1, M > &l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
field_basic< T1, M > &	operator-= (field_basic< T1, M > &l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
field_basic< T, M > &	operator-= (field_basic< T, M > &l, const field_expr< Expr > &r)
template<class T , class M >
field_indirect< T, M >	operator-= (field_indirect< T, M > l, const int &r)
template<class T , class M >
field_indirect< T, M >	operator-= (field_indirect< T, M > l, const T &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator-= (field_indirect< T1, M > l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator-= (field_indirect< T1, M > l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator-= (field_indirect< T1, M > l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator-= (field_indirect< T1, M > l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
field_indirect< T1, M >	operator-= (field_indirect< T1, M > l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
field_indirect< T, M >	operator-= (field_indirect< T, M > l, const field_expr< Expr > &r)
template<class T , class M >
field_component< T, M >	operator-= (field_component< T, M > l, const int &r)
template<class T , class M >
field_component< T, M >	operator-= (field_component< T, M > l, const T &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator-= (field_component< T1, M > l, const field_basic< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator-= (field_component< T1, M > l, const field_indirect< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator-= (field_component< T1, M > l, const field_indirect_const< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator-= (field_component< T1, M > l, const field_component< T2, M > &r)
template<class T1 , class T2 , class M >
field_component< T1, M >	operator-= (field_component< T1, M > l, const field_component_const< T2, M > &r)
template<class T , class M , class Expr >
field_component< T, M >	operator-= (field_component< T, M > l, const field_expr< Expr > &r)
template<class T , class M >
field_basic< T, M > &	operator*= (field_basic< T, M > &l, const int &r)
template<class T , class M >
field_basic< T, M > &	operator*= (field_basic< T, M > &l, const T &r)
template<class T , class M >
field_indirect< T, M >	operator*= (field_indirect< T, M > l, const int &r)
template<class T , class M >
field_indirect< T, M >	operator*= (field_indirect< T, M > l, const T &r)
template<class T , class M >
field_component< T, M >	operator*= (field_component< T, M > l, const int &r)
template<class T , class M >
field_component< T, M >	operator*= (field_component< T, M > l, const T &r)
template<class T , class M >
field_basic< T, M > &	operator/= (field_basic< T, M > &l, const int &r)
template<class T , class M >
field_basic< T, M > &	operator/= (field_basic< T, M > &l, const T &r)
template<class T , class M >
field_indirect< T, M >	operator/= (field_indirect< T, M > l, const int &r)
template<class T , class M >
field_indirect< T, M >	operator/= (field_indirect< T, M > l, const T &r)
template<class T , class M >
field_component< T, M >	operator/= (field_component< T, M > l, const int &r)
template<class T , class M >
field_component< T, M >	operator/= (field_component< T, M > l, const T &r)
template<class T , class M >
T	dual (const field_basic< T, M > &x, const int &y)
template<class T , class M >
T	dual (const int &x, const field_basic< T, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_basic< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const T1 &x, const field_basic< T2, M > &y)
template<class T , class M >
T	dual (const field_indirect< T, M > &x, const int &y)
template<class T , class M >
T	dual (const int &x, const field_indirect< T, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const T1 &x, const field_indirect< T2, M > &y)
template<class T , class M >
T	dual (const field_indirect_const< T, M > &x, const int &y)
template<class T , class M >
T	dual (const int &x, const field_indirect_const< T, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect_const< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const T1 &x, const field_indirect_const< T2, M > &y)
template<class T , class M >
T	dual (const field_component< T, M > &x, const int &y)
template<class T , class M >
T	dual (const int &x, const field_component< T, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const T1 &x, const field_component< T2, M > &y)
template<class T , class M >
T	dual (const field_component_const< T, M > &x, const int &y)
template<class T , class M >
T	dual (const int &x, const field_component_const< T, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component_const< T1, M > &x, const T2 &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const T1 &x, const field_component_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_basic< T1, M > &x, const field_basic< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_basic< T1, M > &x, const field_indirect< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_basic< T1, M > &x, const field_indirect_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_basic< T1, M > &x, const field_component< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_basic< T1, M > &x, const field_component_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect< T1, M > &x, const field_basic< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect< T1, M > &x, const field_indirect< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect< T1, M > &x, const field_indirect_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect< T1, M > &x, const field_component< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect< T1, M > &x, const field_component_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect_const< T1, M > &x, const field_basic< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect_const< T1, M > &x, const field_indirect< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect_const< T1, M > &x, const field_indirect_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect_const< T1, M > &x, const field_component< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_indirect_const< T1, M > &x, const field_component_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component< T1, M > &x, const field_basic< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component< T1, M > &x, const field_indirect< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component< T1, M > &x, const field_indirect_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component< T1, M > &x, const field_component< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component< T1, M > &x, const field_component_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component_const< T1, M > &x, const field_basic< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component_const< T1, M > &x, const field_indirect< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component_const< T1, M > &x, const field_indirect_const< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component_const< T1, M > &x, const field_component< T2, M > &y)
template<class T1 , class T2 , class M >
promote< T1, T2 >::type	dual (const field_component_const< T1, M > &x, const field_component_const< T2, M > &y)
template<class Expr >
field_expr< Expr >::scalar_type	dual (const field_expr< Expr > &x, const int &y)
template<class Expr >
field_expr< Expr >::scalar_type	dual (const int &x, const field_expr< Expr > &y)
template<class T , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_expr< Expr > &x, const T &y)
template<class T , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const T &x, const field_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_basic< T, M > &x, const field_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_expr< Expr > &x, const field_basic< T, M > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_indirect< T, M > &x, const field_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_expr< Expr > &x, const field_indirect< T, M > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_indirect_const< T, M > &x, const field_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_expr< Expr > &x, const field_indirect_const< T, M > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_component< T, M > &x, const field_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_expr< Expr > &x, const field_component< T, M > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_component_const< T, M > &x, const field_expr< Expr > &y)
template<class T , class M , class Expr >
promote< T, typename field_expr< Expr > ::scalar_type >::type	dual (const field_expr< Expr > &x, const field_component_const< T, M > &y)
template<class Expr1 , class Expr2 >
promote< typename field_expr < Expr1 >::scalar_type, typename field_expr< Expr2 > ::scalar_type >::type	dual (const field_expr< Expr1 > &x, const field_expr< Expr2 > &y)
template<class T , class M >
odiststream &	operator<< (odiststream &ops, const field_indirect< T, M > &uh)
template<class T , class M >
odiststream &	operator<< (odiststream &ops, const field_indirect_const< T, M > &uh)
template<class Function >
field_expr_terminal_function < Function >	field_function (const Function &f)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < detail_nonlinear_expr::unary_plus,field_nonlinear_expr < Expr > > >	operator+ (const field_nonlinear_expr< Expr > &x)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < detail_nonlinear_expr::unary_plus,field_expr_terminal_function < Function > > >	operator+ (const field_expr_terminal_function< Function > &x)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < detail_nonlinear_expr::negate,field_nonlinear_expr < Expr > > >	operator- (const field_nonlinear_expr< Expr > &x)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < detail_nonlinear_expr::negate,field_expr_terminal_function < Function > > >	operator- (const field_expr_terminal_function< Function > &x)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder1st< std::plus < typename field_nonlinear_expr< Expr > ::scalar_type > >,field_nonlinear_expr< Expr > >>	operator+ (const typename field_nonlinear_expr< Expr >::scalar_type &x, const field_nonlinear_expr< Expr > &y)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder1st< std::plus < typename field_expr_terminal_function < Function >::scalar_type > >,field_expr_terminal_function < Function > >>	operator+ (const typename field_expr_terminal_function< Function >::scalar_type &x, const field_expr_terminal_function< Function > &y)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder2nd< std::plus < typename field_nonlinear_expr< Expr > ::scalar_type > >,field_nonlinear_expr< Expr > >>	operator+ (const field_nonlinear_expr< Expr > &x, const typename field_nonlinear_expr< Expr >::scalar_type &y)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder2nd< std::plus < typename field_expr_terminal_function < Function >::scalar_type > >,field_expr_terminal_function < Function > >>	operator+ (const field_expr_terminal_function< Function > &x, const typename field_expr_terminal_function< Function >::scalar_type &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator+ (const field_basic< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_basic< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator+ (const field_nonlinear_expr< Expr > &x, const field_basic< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator+ (const field_basic< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator+ (const field_indirect< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_indirect< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator+ (const field_nonlinear_expr< Expr > &x, const field_indirect< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator+ (const field_indirect< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator+ (const field_indirect_const< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_indirect_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator+ (const field_nonlinear_expr< Expr > &x, const field_indirect_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator+ (const field_indirect_const< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator+ (const field_component< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_component< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator+ (const field_nonlinear_expr< Expr > &x, const field_component< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator+ (const field_component< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator+ (const field_component_const< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_component_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator+ (const field_nonlinear_expr< Expr > &x, const field_component_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator+ (const field_component_const< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > ,field_expr_terminal_function < Function > > >	operator+ (const field_expr< Expr > &x, const field_expr_terminal_function< Function > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_expr< Expr > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr > ,field_expr_terminal_function < Function > > >	operator+ (const field_nonlinear_expr< Expr > &x, const field_expr_terminal_function< Function > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function > ,field_nonlinear_expr< Expr > > >	operator+ (const field_expr_terminal_function< Function > &x, const field_nonlinear_expr< Expr > &y)
template<class Expr1 , class Expr2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_field < typename field_expr< Expr1 > ::scalar_type, typename field_expr< Expr1 > ::memory_type > ,field_nonlinear_expr< Expr2 > > >	operator+ (const field_expr< Expr1 > &x, const field_nonlinear_expr< Expr2 > &y)
template<class Expr1 , class Expr2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr1 > ,field_expr_terminal_field < typename field_expr< Expr2 > ::scalar_type, typename field_expr< Expr2 > ::memory_type > > >	operator+ (const field_nonlinear_expr< Expr1 > &x, const field_expr< Expr2 > &y)
template<class Function1 , class Function2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_expr_terminal_function < Function1 > ,field_expr_terminal_function < Function2 > > >	operator+ (const field_expr_terminal_function< Function1 > &x, const field_expr_terminal_function< Function2 > &y)
template<class Expr1 , class Expr2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::plus,field_nonlinear_expr < Expr1 >,field_nonlinear_expr < Expr2 > > >	operator+ (const field_nonlinear_expr< Expr1 > &x, const field_nonlinear_expr< Expr2 > &y)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder1st< std::minus < typename field_nonlinear_expr< Expr > ::scalar_type > >,field_nonlinear_expr< Expr > >>	operator- (const typename field_nonlinear_expr< Expr >::scalar_type &x, const field_nonlinear_expr< Expr > &y)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder1st< std::minus < typename field_expr_terminal_function < Function >::scalar_type > >,field_expr_terminal_function < Function > >>	operator- (const typename field_expr_terminal_function< Function >::scalar_type &x, const field_expr_terminal_function< Function > &y)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder2nd< std::minus < typename field_nonlinear_expr< Expr > ::scalar_type > >,field_nonlinear_expr< Expr > >>	operator- (const field_nonlinear_expr< Expr > &x, const typename field_nonlinear_expr< Expr >::scalar_type &y)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder2nd< std::minus < typename field_expr_terminal_function < Function >::scalar_type > >,field_expr_terminal_function < Function > >>	operator- (const field_expr_terminal_function< Function > &x, const typename field_expr_terminal_function< Function >::scalar_type &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator- (const field_basic< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator- (const field_expr_terminal_function< Function > &x, const field_basic< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator- (const field_nonlinear_expr< Expr > &x, const field_basic< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator- (const field_basic< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator- (const field_indirect< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator- (const field_expr_terminal_function< Function > &x, const field_indirect< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator- (const field_nonlinear_expr< Expr > &x, const field_indirect< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator- (const field_indirect< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator- (const field_indirect_const< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator- (const field_expr_terminal_function< Function > &x, const field_indirect_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator- (const field_nonlinear_expr< Expr > &x, const field_indirect_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator- (const field_indirect_const< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator- (const field_component< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator- (const field_expr_terminal_function< Function > &x, const field_component< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator- (const field_nonlinear_expr< Expr > &x, const field_component< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator- (const field_component< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator- (const field_component_const< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator- (const field_expr_terminal_function< Function > &x, const field_component_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator- (const field_nonlinear_expr< Expr > &x, const field_component_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator- (const field_component_const< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > ,field_expr_terminal_function < Function > > >	operator- (const field_expr< Expr > &x, const field_expr_terminal_function< Function > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > > >	operator- (const field_expr_terminal_function< Function > &x, const field_expr< Expr > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr > ,field_expr_terminal_function < Function > > >	operator- (const field_nonlinear_expr< Expr > &x, const field_expr_terminal_function< Function > &y)
template<class Expr , class Function >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function > ,field_nonlinear_expr< Expr > > >	operator- (const field_expr_terminal_function< Function > &x, const field_nonlinear_expr< Expr > &y)
template<class Expr1 , class Expr2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_field < typename field_expr< Expr1 > ::scalar_type, typename field_expr< Expr1 > ::memory_type > ,field_nonlinear_expr< Expr2 > > >	operator- (const field_expr< Expr1 > &x, const field_nonlinear_expr< Expr2 > &y)
template<class Expr1 , class Expr2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr1 > ,field_expr_terminal_field < typename field_expr< Expr2 > ::scalar_type, typename field_expr< Expr2 > ::memory_type > > >	operator- (const field_nonlinear_expr< Expr1 > &x, const field_expr< Expr2 > &y)
template<class Function1 , class Function2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_expr_terminal_function < Function1 > ,field_expr_terminal_function < Function2 > > >	operator- (const field_expr_terminal_function< Function1 > &x, const field_expr_terminal_function< Function2 > &y)
template<class Expr1 , class Expr2 >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::minus,field_nonlinear_expr < Expr1 >,field_nonlinear_expr < Expr2 > > >	operator- (const field_nonlinear_expr< Expr1 > &x, const field_nonlinear_expr< Expr2 > &y)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder1st < std::multiplies< typename field_nonlinear_expr< Expr > ::scalar_type > >,field_nonlinear_expr< Expr > >>	operator* (const typename field_nonlinear_expr< Expr >::scalar_type &x, const field_nonlinear_expr< Expr > &y)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder1st < std::multiplies< typename field_expr_terminal_function < Function >::scalar_type > >,field_expr_terminal_function < Function > >>	operator* (const typename field_expr_terminal_function< Function >::scalar_type &x, const field_expr_terminal_function< Function > &y)
template<class Expr >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder2nd < std::multiplies< typename field_nonlinear_expr< Expr > ::scalar_type > >,field_nonlinear_expr< Expr > >>	operator* (const field_nonlinear_expr< Expr > &x, const typename field_nonlinear_expr< Expr >::scalar_type &y)
template<class Function >
field_nonlinear_expr < field_nonlinear_expr_uf < std::binder2nd < std::multiplies< typename field_expr_terminal_function < Function >::scalar_type > >,field_expr_terminal_function < Function > >>	operator* (const field_expr_terminal_function< Function > &x, const typename field_expr_terminal_function< Function >::scalar_type &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_basic< T, M > &x, const field_basic< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_basic< T, M > &x, const field_indirect< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_basic< T, M > &x, const field_indirect_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_basic< T, M > &x, const field_component< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_basic< T, M > &x, const field_component_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect< T, M > &x, const field_basic< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect< T, M > &x, const field_indirect< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect< T, M > &x, const field_indirect_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect< T, M > &x, const field_component< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect< T, M > &x, const field_component_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect_const< T, M > &x, const field_basic< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect_const< T, M > &x, const field_indirect< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect_const< T, M > &x, const field_indirect_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect_const< T, M > &x, const field_component< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_indirect_const< T, M > &x, const field_component_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component< T, M > &x, const field_basic< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component< T, M > &x, const field_indirect< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component< T, M > &x, const field_indirect_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component< T, M > &x, const field_component< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component< T, M > &x, const field_component_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component_const< T, M > &x, const field_basic< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component_const< T, M > &x, const field_indirect< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component_const< T, M > &x, const field_indirect_const< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component_const< T, M > &x, const field_component< T, M > &y)
template<class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field< T, M > > >	operator* (const field_component_const< T, M > &x, const field_component_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > > >	operator* (const field_basic< T, M > &x, const field_expr< Expr > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > ,field_expr_terminal_field< T, M > > >	operator* (const field_expr< Expr > &x, const field_basic< T, M > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator* (const field_basic< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator* (const field_expr_terminal_function< Function > &x, const field_basic< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator* (const field_nonlinear_expr< Expr > &x, const field_basic< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator* (const field_basic< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > > >	operator* (const field_indirect< T, M > &x, const field_expr< Expr > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > ,field_expr_terminal_field< T, M > > >	operator* (const field_expr< Expr > &x, const field_indirect< T, M > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator* (const field_indirect< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator* (const field_expr_terminal_function< Function > &x, const field_indirect< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator* (const field_nonlinear_expr< Expr > &x, const field_indirect< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >	operator* (const field_indirect< T, M > &x, const field_nonlinear_expr< Expr > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > > >	operator* (const field_indirect_const< T, M > &x, const field_expr< Expr > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < typename field_expr< Expr > ::scalar_type, typename field_expr< Expr > ::memory_type > ,field_expr_terminal_field< T, M > > >	operator* (const field_expr< Expr > &x, const field_indirect_const< T, M > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M > ,field_expr_terminal_function < Function > > >	operator* (const field_indirect_const< T, M > &x, const field_expr_terminal_function< Function > &y)
template<class Function , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_function < Function > ,field_expr_terminal_field< T, M > > >	operator* (const field_expr_terminal_function< Function > &x, const field_indirect_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_nonlinear_expr < Expr > ,field_expr_terminal_field< T, M > > >	operator* (const field_nonlinear_expr< Expr > &x, const field_indirect_const< T, M > &y)
template<class Expr , class T , class M >
field_nonlinear_expr < field_nonlinear_expr_bf < detail_nonlinear_expr::multiplies,field_expr_terminal_field < T, M >,field_nonlinear_expr < Expr > > >