FieldFieldFunctions.H File Reference

Include dependency graph for FieldFieldFunctions.H:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	Foam
	Namespace for OpenFOAM.

Macros
#define	TEMPLATE   template<template<class> class Field, class Type>
#define	TMP_UNARY_FUNCTION(returnType, func)
#define	G_UNARY_FUNCTION(ReturnType, gFunc, func, rFunc)
#define	PRODUCT_OPERATOR(product, op, opFunc)

Functions
template<template< class > class Field, class Type>
void	component (FieldField< Field, typename FieldField< Field, Type >::cmptType > &sf, const FieldField< Field, Type > &f, const direction d)
template<template< class > class Field, class Type>
void	T (FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type, direction r>
void	pow (FieldField< Field, typename powProduct< Type, r >::type > &f, const FieldField< Field, Type > &vf)
template<template< class > class Field, class Type, direction r>
tmp< FieldField< Field, typename powProduct< Type, r >::type > >	pow (const FieldField< Field, Type > &f, typename powProduct< Type, r >::type)
template<template< class > class Field, class Type, direction r>
tmp< FieldField< Field, typename powProduct< Type, r >::type > >	pow (const tmp< FieldField< Field, Type > > &tf, typename powProduct< Type, r >::type)
template<template< class > class Field, class Type>
void	sqr (FieldField< Field, typename outerProduct< Type, Type >::type > &f, const FieldField< Field, Type > &vf)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename outerProduct< Type, Type >::type > >	sqr (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename outerProduct< Type, Type >::type > >	sqr (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void	magSqr (FieldField< Field, typename typeOfMag< Type >::type > &sf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename typeOfMag< Type >::type > >	magSqr (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename typeOfMag< Type >::type > >	magSqr (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void	mag (FieldField< Field, typename typeOfMag< Type >::type > &sf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename typeOfMag< Type >::type > >	mag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename typeOfMag< Type >::type > >	mag (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void	cmptMax (FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename FieldField< Field, Type >::cmptType > >	cmptMax (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename FieldField< Field, Type >::cmptType > >	cmptMax (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void	cmptMin (FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename FieldField< Field, Type >::cmptType > >	cmptMin (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename FieldField< Field, Type >::cmptType > >	cmptMin (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void	cmptAv (FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename FieldField< Field, Type >::cmptType > >	cmptAv (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename FieldField< Field, Type >::cmptType > >	cmptAv (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void	cmptMag (FieldField< Field, Type > &cf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMag (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
Type	max (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type	max (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	min (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type	min (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	sum (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type	sum (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
typeOfMag< Type >::type	sumMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
typeOfMag< Type >::type	sumMag (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	average (const FieldField< Field, Type > &f)
	The local arithmetic average of a FieldField.
template<template< class > class Field, class Type>
Type	average (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
MinMax< Type >	minMax (const FieldField< Field, Type > &f)
	Return min/max for a field of fields.
template<template< class > class Field, class Type>
MinMax< Type >	minMax (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
scalarMinMax	minMaxMag (const FieldField< Field, Type > &f)
	Return mag min/max for a field of fields.
template<template< class > class Field, class Type>
scalarMinMax	minMaxMag (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	gMax (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type	gMax (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	gMin (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type	gMin (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	gSum (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type	gSum (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
MinMax< Type >	gMinMax (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
MinMax< Type >	gMinMax (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
scalarMinMax	gMinMaxMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
scalarMinMax	gMinMaxMag (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
typeOfMag< Type >::type	gSumMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
typeOfMag< Type >::type	gSumMag (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type	gAverage (const FieldField< Field, Type > &f, const label comm=UPstream::worldComm)
	The global arithmetic average of a FieldField.
template<template< class > class Field, class Type>
Type	gAverage (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void	max (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	min (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	cmptMultiply (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	cmptDivide (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	max (FieldField< Field, Type > &result, const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const Type &s1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	max (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	max (const tmp< FieldField< Field, Type > > &tf1, const Type &s2)
template<template< class > class Field, class Type>
void	min (FieldField< Field, Type > &result, const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const Type &s1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	min (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	min (const tmp< FieldField< Field, Type > > &tf1, const Type &s2)
template<template< class > class Field, class Type>
void	cmptMultiply (FieldField< Field, Type > &result, const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const Type &s1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	cmptMultiply (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptMultiply (const tmp< FieldField< Field, Type > > &tf1, const Type &s2)
template<template< class > class Field, class Type>
void	cmptDivide (FieldField< Field, Type > &result, const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const Type &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const Type &s1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	cmptDivide (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const FieldField< Field, Type > &f1, const Type &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	cmptDivide (const tmp< FieldField< Field, Type > > &tf1, const Type &s2)
template<template< class > class Field, class Type>
void	clamp (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const MinMax< Type > &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	clamp (const FieldField< Field, Type > &f1, const MinMax< Type > &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	clamp (const tmp< FieldField< Field, Type > > &tf1, const MinMax< Type > &s2)
template<template< class > class Field, class Type>
void	lerp (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2, const FieldField< Field, scalar > &f3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2, const FieldField< Field, scalar > &f3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2, const FieldField< Field, scalar > &f3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2, const FieldField< Field, scalar > &f3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2, const tmp< FieldField< Field, scalar > > &tf3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2, const FieldField< Field, scalar > &f3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2, const tmp< FieldField< Field, scalar > > &tf3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2, const tmp< FieldField< Field, scalar > > &tf3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2, const tmp< FieldField< Field, scalar > > &tf3)
template<template< class > class Field, class Type>
void	lerp (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2, const scalar &s3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2, const scalar &s3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2, const scalar &s3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2, const scalar &s3)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	lerp (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2, const scalar &s3)
template<template< class > class Field, class Type>
void	negate (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator- (const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator- (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void	multiply (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, scalar > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, scalar > > &tf2)
template<template< class > class Field, class Type>
void	multiply (FieldField< Field, Type > &result, const FieldField< Field, scalar > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const FieldField< Field, scalar > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const FieldField< Field, scalar > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const tmp< FieldField< Field, scalar > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const tmp< FieldField< Field, scalar > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	divide (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator/ (const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator/ (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, scalar > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator/ (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator/ (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, scalar > > &tf2)
template<template< class > class Field, class Type>
void	multiply (FieldField< Field, Type > &result, const scalar &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const scalar &s1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const scalar &s1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void	multiply (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const scalar &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const FieldField< Field, Type > &f1, const scalar &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator* (const tmp< FieldField< Field, Type > > &tf1, const scalar &s2)
template<template< class > class Field, class Type>
void	divide (FieldField< Field, Type > &result, const FieldField< Field, Type > &f1, const scalar &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator/ (const FieldField< Field, Type > &f1, const scalar &s2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > >	operator/ (const tmp< FieldField< Field, Type > > &tf1, const scalar &s2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
void	add (FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator+ (const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename typeOfSum< Type1, Type2 >::type > >	operator+ (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator+ (const FieldField< Field1, Type1 > &f1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator+ (const tmp< FieldField< Field1, Type1 > > &tf1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator+ (const tmp< FieldField< Field1, Type1 > > &tf1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	add (FieldField< Field, typename typeOfSum< Type, Form >::type > &result, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Type, Form >::type > >	operator+ (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Type, Form >::type > >	operator+ (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	add (FieldField< Field, typename typeOfSum< Form, Type >::type > &result, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Form, Type >::type > >	operator+ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Form, Type >::type > >	operator+ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
void	subtract (FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator- (const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename typeOfSum< Type1, Type2 >::type > >	operator- (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator- (const FieldField< Field1, Type1 > &f1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator- (const tmp< FieldField< Field1, Type1 > > &tf1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > >	operator- (const tmp< FieldField< Field1, Type1 > > &tf1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	subtract (FieldField< Field, typename typeOfSum< Type, Form >::type > &result, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Type, Form >::type > >	operator- (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Type, Form >::type > >	operator- (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	subtract (FieldField< Field, typename typeOfSum< Form, Type >::type > &result, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Form, Type >::type > >	operator- (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename typeOfSum< Form, Type >::type > >	operator- (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
void	outer (FieldField< Field1, typename outerProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename outerProduct< Type1, Type2 >::type > >	operator* (const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename outerProduct< Type1, Type2 >::type > >	operator* (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename outerProduct< Type1, Type2 >::type > >	operator* (const FieldField< Field1, Type1 > &f1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename outerProduct< Type1, Type2 >::type > >	operator* (const tmp< FieldField< Field1, Type1 > > &tf1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename outerProduct< Type1, Type2 >::type > >	operator* (const tmp< FieldField< Field1, Type1 > > &tf1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	outer (FieldField< Field, typename outerProduct< Type, Form >::type > &result, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename outerProduct< Type, Form >::type > >	operator* (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename outerProduct< Type, Form >::type > >	operator* (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	outer (FieldField< Field, typename outerProduct< Form, Type >::type > &result, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename outerProduct< Form, Type >::type > >	operator* (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename outerProduct< Form, Type >::type > >	operator* (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
void	cross (FieldField< Field1, typename crossProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename crossProduct< Type1, Type2 >::type > >	operator^ (const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename crossProduct< Type1, Type2 >::type > >	operator^ (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename crossProduct< Type1, Type2 >::type > >	operator^ (const FieldField< Field1, Type1 > &f1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename crossProduct< Type1, Type2 >::type > >	operator^ (const tmp< FieldField< Field1, Type1 > > &tf1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename crossProduct< Type1, Type2 >::type > >	operator^ (const tmp< FieldField< Field1, Type1 > > &tf1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	cross (FieldField< Field, typename crossProduct< Type, Form >::type > &result, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename crossProduct< Type, Form >::type > >	operator^ (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename crossProduct< Type, Form >::type > >	operator^ (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	cross (FieldField< Field, typename crossProduct< Form, Type >::type > &result, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename crossProduct< Form, Type >::type > >	operator^ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename crossProduct< Form, Type >::type > >	operator^ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
void	dot (FieldField< Field1, typename innerProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename innerProduct< Type1, Type2 >::type > >	operator& (const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename innerProduct< Type1, Type2 >::type > >	operator& (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename innerProduct< Type1, Type2 >::type > >	operator& (const FieldField< Field1, Type1 > &f1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename innerProduct< Type1, Type2 >::type > >	operator& (const tmp< FieldField< Field1, Type1 > > &tf1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename innerProduct< Type1, Type2 >::type > >	operator& (const tmp< FieldField< Field1, Type1 > > &tf1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	dot (FieldField< Field, typename innerProduct< Type, Form >::type > &result, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename innerProduct< Type, Form >::type > >	operator& (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename innerProduct< Type, Form >::type > >	operator& (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	dot (FieldField< Field, typename innerProduct< Form, Type >::type > &result, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename innerProduct< Form, Type >::type > >	operator& (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename innerProduct< Form, Type >::type > >	operator& (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
void	dotdot (FieldField< Field1, typename scalarProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename scalarProduct< Type1, Type2 >::type > >	operator&& (const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename scalarProduct< Type1, Type2 >::type > >	operator&& (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename scalarProduct< Type1, Type2 >::type > >	operator&& (const FieldField< Field1, Type1 > &f1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename scalarProduct< Type1, Type2 >::type > >	operator&& (const tmp< FieldField< Field1, Type1 > > &tf1, const FieldField< Field2, Type2 > &f2)
template<template< class > class Field1, template< class > class Field2, class Type1, class Type2>
tmp< FieldField< Field1, typename scalarProduct< Type1, Type2 >::type > >	operator&& (const tmp< FieldField< Field1, Type1 > > &tf1, const tmp< FieldField< Field2, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	dotdot (FieldField< Field, typename scalarProduct< Type, Form >::type > &result, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename scalarProduct< Type, Form >::type > >	operator&& (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename scalarProduct< Type, Form >::type > >	operator&& (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
void	dotdot (FieldField< Field, typename scalarProduct< Form, Type >::type > &result, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename scalarProduct< Form, Type >::type > >	operator&& (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type, class Form, class Cmpt, direction nCmpt>
tmp< FieldField< Field, typename scalarProduct< Form, Type >::type > >	operator&& (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)

Detailed Description

Original source file FieldFieldFunctions.H

Definition in file FieldFieldFunctions.H.

Macro Definition Documentation

TEMPLATE

#define TEMPLATE   template<template<class> class Field, class Type>

Definition at line 24 of file FieldFieldFunctions.H.

TMP_UNARY_FUNCTION

#define TMP_UNARY_FUNCTION	(		returnType,
			func )

Value:

                                                                               \
template<template<class> class Field, class Type>                              \
returnType func(const tmp<FieldField<Field, Type>>& tf1);

Definition at line 198 of file FieldFieldFunctions.H.

G_UNARY_FUNCTION

#define G_UNARY_FUNCTION	(		ReturnType,
			gFunc,
			func,
			rFunc )

Value:

                                                                               \
template<template<class> class Field, class Type>                              \
ReturnType gFunc(const FieldField<Field, Type>& f);                            \
TMP_UNARY_FUNCTION(ReturnType, gFunc)

Definition at line 255 of file FieldFieldFunctions.H.

PRODUCT_OPERATOR

#define PRODUCT_OPERATOR	(		product,
			op,
			opFunc )

Definition at line 323 of file FieldFieldFunctions.H.