OpenFOAM logo
Open Source CFD Toolkit

FieldFunctions.H File Reference


Detailed Description

View FieldFunctions.H
License
This file is part of OpenFOAM.

OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.

OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Generic field type.

Definition in file FieldFunctions.H.

Go to the source code of this file.

Namespaces

namespace  Foam

Defines

#define BINARY_FUNCTION(Func)
#define TMP_UNARY_FUNCTION(ReturnType, Func)
#define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc)
#define UNARY_OPERATOR(Op, OpFunc)
#define BINARY_OPERATOR_FF(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_FR(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_FT(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_RF(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_TF(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_RT(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_TR(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_RR(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_RN(Type1, Type2, Op, OpFunc)
#define BINARY_OPERATOR_NR(Type1, Type2, Op, OpFunc)
#define BINARY_TYPE_OPERATOR_SF(TYPE, Op, OpFunc)
#define BINARY_TYPE_OPERATOR_FS(TYPE, Op, OpFunc)
#define BINARY_TYPE_OPERATOR(TYPE, Op, OpFunc)
#define PRODUCT_OPERATOR(product, Op, OpFunc)

Functions

template<class Type>
void component (Field< typename Field< Type >::cmptType > &sf, const UList< Type > &f, const direction d)
template<class Type>
void T (Field< Type > &f1, const UList< Type > &f2)
template<class Type, int r>
void pow (Field< typename powProduct< Type, r >::type > &f, const UList< Type > &vf)
template<class Type, int r>
tmp< Field< typename powProduct<
Type, r >::type > > 
pow (const UList< Type > &f, typename powProduct< Type, r >::type=pTraits< typename powProduct< Type, r >::type >::zero)
template<class Type, int r>
tmp< Field< typename powProduct<
Type, r >::type > > 
pow (const tmp< Field< Type > > &tf, typename powProduct< Type, r >::type=pTraits< typename powProduct< Type, r >::type >::zero)
template<class Type>
void sqr (Field< typename outerProduct< Type, Type >::type > &f, const UList< Type > &vf)
template<class Type>
tmp< Field< typename outerProduct<
Type, Type >::type > > 
sqr (const UList< Type > &f)
template<class Type>
tmp< Field< typename outerProduct<
Type, Type >::type > > 
sqr (const tmp< Field< Type > > &tf)
template<class Type>
void magSqr (Field< scalar > &sf, const UList< Type > &f)
template<class Type>
tmp< Field< scalar > > magSqr (const UList< Type > &f)
template<class Type>
tmp< Field< scalar > > magSqr (const tmp< Field< Type > > &tf)
template<class Type>
void mag (Field< scalar > &sf, const UList< Type > &f)
template<class Type>
tmp< Field< scalar > > mag (const UList< Type > &f)
template<class Type>
tmp< Field< scalar > > mag (const tmp< Field< Type > > &tf)
template<class Type>
void cmptAv (Field< typename Field< Type >::cmptType > &cf, const UList< Type > &f)
template<class Type>
tmp< Field< typename Field<
Type >::cmptType > > 
cmptAv (const UList< Type > &f)
template<class Type>
tmp< Field< typename Field<
Type >::cmptType > > 
cmptAv (const tmp< Field< Type > > &tf)
template<class Type>
void cmptMag (Field< Type > &cf, const UList< Type > &f)
template<class Type>
tmp< Field< Type > > cmptMag (const UList< Type > &f)
template<class Type>
tmp< Field< Type > > cmptMag (const tmp< Field< Type > > &tf)
template<class Type>
void max (Field< Type > &f, const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > max (const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > max (const UList< Type > &f1, const tmp< Field< Type > > &tf2)
template<class Type>
tmp< Field< Type > > max (const tmp< Field< Type > > &tf1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > max (const tmp< Field< Type > > &tf1, const tmp< Field< Type > > &tf2)
template<class Type>
void max (Field< Type > &f, const UList< Type > &f1, const Type &s)
template<class Type>
tmp< Field< Type > > max (const UList< Type > &f1, const Type &s)
template<class Type>
tmp< Field< Type > > max (const tmp< Field< Type > > &tf1, const Type &s)
template<class Type>
void min (Field< Type > &f, const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > min (const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > min (const UList< Type > &f1, const tmp< Field< Type > > &tf2)
template<class Type>
tmp< Field< Type > > min (const tmp< Field< Type > > &tf1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > min (const tmp< Field< Type > > &tf1, const tmp< Field< Type > > &tf2)
template<class Type>
void min (Field< Type > &f, const UList< Type > &f1, const Type &s)
template<class Type>
tmp< Field< Type > > min (const UList< Type > &f1, const Type &s)
template<class Type>
tmp< Field< Type > > min (const tmp< Field< Type > > &tf1, const Type &s)
template<class Type>
void scale (Field< Type > &f, const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > scale (const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > scale (const UList< Type > &f1, const tmp< Field< Type > > &tf2)
template<class Type>
tmp< Field< Type > > scale (const tmp< Field< Type > > &tf1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > scale (const tmp< Field< Type > > &tf1, const tmp< Field< Type > > &tf2)
template<class Type>
void scale (Field< Type > &f, const UList< Type > &f1, const Type &s)
template<class Type>
tmp< Field< Type > > scale (const UList< Type > &f1, const Type &s)
template<class Type>
tmp< Field< Type > > scale (const tmp< Field< Type > > &tf1, const Type &s)
template<class Type>
Type max (const UList< Type > &f)
template<class Type>
Type max (const tmp< Field< Type > > &tf1)
template<class Type>
Type min (const UList< Type > &f)
template<class Type>
Type min (const tmp< Field< Type > > &tf1)
template<class Type>
Type sum (const UList< Type > &f)
template<class Type>
Type sum (const tmp< Field< Type > > &tf1)
template<class Type>
scalar sumProd (const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
scalar sumSqr (const UList< Type > &f)
template<class Type>
scalar sumSqr (const tmp< Field< Type > > &tf1)
template<class Type>
scalar sumMag (const UList< Type > &f)
template<class Type>
scalar sumMag (const tmp< Field< Type > > &tf1)
template<class Type>
Type average (const UList< Type > &f)
template<class Type>
Type average (const tmp< Field< Type > > &tf1)
template<class Type>
Type gMax (const UList< Type > &f)
template<class Type>
Type gMax (const tmp< Field< Type > > &tf1)
template<class Type>
Type gMin (const UList< Type > &f)
template<class Type>
Type gMin (const tmp< Field< Type > > &tf1)
template<class Type>
Type gSum (const UList< Type > &f)
template<class Type>
Type gSum (const tmp< Field< Type > > &tf1)
template<class Type>
scalar gSumSqr (const UList< Type > &f)
template<class Type>
scalar gSumSqr (const tmp< Field< Type > > &tf1)
template<class Type>
scalar gSumMag (const UList< Type > &f)
template<class Type>
scalar gSumMag (const tmp< Field< Type > > &tf1)
template<class Type>
scalar gSumProd (const UList< Type > &f1, const UList< Type > &f2)
template<class Type>
Type gAverage (const UList< Type > &f)
template<class Type>
Type gAverage (const tmp< Field< Type > > &tf1)
template<class Type>
void negate (Field< Type > &f, const UList< Type > &f1)
template<class Type>
tmp< Field< Type > > operator- (const UList< Type > &f1)
template<class Type>
tmp< Field< Type > > operator- (const tmp< Field< Type > > &tf1)
template<class Type>
void multiply (Field< Type > &f, const UList< Type > &f1, const UList< scalar > &f2)
template<class Type>
tmp< Field< Type > > operator * (const UList< Type > &f1, const UList< scalar > &f2)
template<class Type>
tmp< Field< Type > > operator * (const UList< Type > &f1, const tmp< Field< scalar > > &tf2)
template<class Type>
tmp< Field< Type > > operator * (const tmp< Field< Type > > &tf1, const UList< scalar > &f2)
template<class Type>
tmp< Field< Type > > operator * (const tmp< Field< Type > > &tf1, const tmp< Field< scalar > > &tf2)
template<class Type>
void multiply (Field< Type > &f, const UList< scalar > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > operator * (const UList< scalar > &f1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > operator * (const UList< scalar > &f1, const tmp< Field< Type > > &tf2)
template<class Type>
tmp< Field< Type > > operator * (const tmp< Field< scalar > > &tf1, const UList< Type > &f2)
template<class Type>
tmp< Field< Type > > operator * (const tmp< Field< scalar > > &tf1, const tmp< Field< Type > > &tf2)
template<class Type>
void divide (Field< Type > &f, const UList< Type > &f1, const UList< scalar > &f2)
template<class Type>
tmp< Field< Type > > operator/ (const UList< Type > &f1, const UList< scalar > &f2)
template<class Type>
tmp< Field< Type > > operator/ (const UList< Type > &f1, const tmp< Field< scalar > > &tf2)
template<class Type>
tmp< Field< Type > > operator/ (const tmp< Field< Type > > &tf1, const UList< scalar > &f2)
template<class Type>
tmp< Field< Type > > operator/ (const tmp< Field< Type > > &tf1, const tmp< Field< scalar > > &tf2)
template<class Type>
void multiply (Field< Type > &f, const scalar &s, const UList< Type > &f1)
template<class Type>
tmp< Field< Type > > operator * (const scalar &s, const UList< Type > &f1)
template<class Type>
tmp< Field< Type > > operator * (const scalar &s, const tmp< Field< Type > > &tf1)
template<class Type>
void multiply (Field< Type > &f, const UList< Type > &f1, const scalar &s)
template<class Type>
tmp< Field< Type > > operator * (const UList< Type > &f1, const scalar &s)
template<class Type>
tmp< Field< Type > > operator * (const tmp< Field< Type > > &tf1, const scalar &s)
template<class Type>
void divide (Field< Type > &f, const UList< Type > &f1, const scalar &s)
template<class Type>
tmp< Field< Type > > operator/ (const UList< Type > &f1, const scalar &s)
template<class Type>
tmp< Field< Type > > operator/ (const tmp< Field< Type > > &tf1, const scalar &s)
template<class Type1, class Type2>
void add (Field< typename typeOfSum< Type1, Type2 >::type > &f, const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator+ (const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator+ (const UList< Type1 > &f1, const tmp< Field< Type2 > > &tf2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator+ (const tmp< Field< Type1 > > &tf1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator+ (const tmp< Field< Type1 > > &tf1, const tmp< Field< Type2 > > &tf2)
template<class Type, class Form, class Cmpt, int nCmpt>
void add (Field< typename typeOfSum< Type, Form >::type > &f, const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename typeOfSum<
Type, Form >::type > > 
operator+ (const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename typeOfSum<
Type, Form >::type > > 
operator+ (const tmp< Field< Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Form, class Cmpt, int nCmpt, class Type>
void add (Field< typename typeOfSum< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename typeOfSum<
Form, Type >::type > > 
operator+ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename typeOfSum<
Form, Type >::type > > 
operator+ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< Field< Type > > &tf1)
template<class Type1, class Type2>
void subtract (Field< typename typeOfSum< Type1, Type2 >::type > &f, const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator- (const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator- (const UList< Type1 > &f1, const tmp< Field< Type2 > > &tf2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator- (const tmp< Field< Type1 > > &tf1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename typeOfSum<
Type1, Type2 >::type > > 
operator- (const tmp< Field< Type1 > > &tf1, const tmp< Field< Type2 > > &tf2)
template<class Type, class Form, class Cmpt, int nCmpt>
void subtract (Field< typename typeOfSum< Type, Form >::type > &f, const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename typeOfSum<
Type, Form >::type > > 
operator- (const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename typeOfSum<
Type, Form >::type > > 
operator- (const tmp< Field< Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Form, class Cmpt, int nCmpt, class Type>
void subtract (Field< typename typeOfSum< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename typeOfSum<
Form, Type >::type > > 
operator- (const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename typeOfSum<
Form, Type >::type > > 
operator- (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< Field< Type > > &tf1)
template<class Type1, class Type2>
void outer (Field< typename outerProduct< Type1, Type2 >::type > &f, const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename outerProduct<
Type1, Type2 >::type > > 
operator * (const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename outerProduct<
Type1, Type2 >::type > > 
operator * (const UList< Type1 > &f1, const tmp< Field< Type2 > > &tf2)
template<class Type1, class Type2>
tmp< Field< typename outerProduct<
Type1, Type2 >::type > > 
operator * (const tmp< Field< Type1 > > &tf1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename outerProduct<
Type1, Type2 >::type > > 
operator * (const tmp< Field< Type1 > > &tf1, const tmp< Field< Type2 > > &tf2)
template<class Type, class Form, class Cmpt, int nCmpt>
void outer (Field< typename outerProduct< Type, Form >::type > &f, const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename outerProduct<
Type, Form >::type > > 
operator * (const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename outerProduct<
Type, Form >::type > > 
operator * (const tmp< Field< Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Form, class Cmpt, int nCmpt, class Type>
void outer (Field< typename outerProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename outerProduct<
Form, Type >::type > > 
operator * (const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename outerProduct<
Form, Type >::type > > 
operator * (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< Field< Type > > &tf1)
template<class Type1, class Type2>
void cross (Field< typename crossProduct< Type1, Type2 >::type > &f, const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename crossProduct<
Type1, Type2 >::type > > 
operator^ (const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename crossProduct<
Type1, Type2 >::type > > 
operator^ (const UList< Type1 > &f1, const tmp< Field< Type2 > > &tf2)
template<class Type1, class Type2>
tmp< Field< typename crossProduct<
Type1, Type2 >::type > > 
operator^ (const tmp< Field< Type1 > > &tf1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename crossProduct<
Type1, Type2 >::type > > 
operator^ (const tmp< Field< Type1 > > &tf1, const tmp< Field< Type2 > > &tf2)
template<class Type, class Form, class Cmpt, int nCmpt>
void cross (Field< typename crossProduct< Type, Form >::type > &f, const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename crossProduct<
Type, Form >::type > > 
operator^ (const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename crossProduct<
Type, Form >::type > > 
operator^ (const tmp< Field< Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Form, class Cmpt, int nCmpt, class Type>
void cross (Field< typename crossProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename crossProduct<
Form, Type >::type > > 
operator^ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename crossProduct<
Form, Type >::type > > 
operator^ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< Field< Type > > &tf1)
template<class Type1, class Type2>
void dot (Field< typename innerProduct< Type1, Type2 >::type > &f, const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename innerProduct<
Type1, Type2 >::type > > 
operator & (const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename innerProduct<
Type1, Type2 >::type > > 
operator & (const UList< Type1 > &f1, const tmp< Field< Type2 > > &tf2)
template<class Type1, class Type2>
tmp< Field< typename innerProduct<
Type1, Type2 >::type > > 
operator & (const tmp< Field< Type1 > > &tf1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename innerProduct<
Type1, Type2 >::type > > 
operator & (const tmp< Field< Type1 > > &tf1, const tmp< Field< Type2 > > &tf2)
template<class Type, class Form, class Cmpt, int nCmpt>
void dot (Field< typename innerProduct< Type, Form >::type > &f, const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename innerProduct<
Type, Form >::type > > 
operator & (const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename innerProduct<
Type, Form >::type > > 
operator & (const tmp< Field< Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Form, class Cmpt, int nCmpt, class Type>
void dot (Field< typename innerProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename innerProduct<
Form, Type >::type > > 
operator & (const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename innerProduct<
Form, Type >::type > > 
operator & (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< Field< Type > > &tf1)
template<class Type1, class Type2>
void dotdot (Field< typename scalarProduct< Type1, Type2 >::type > &f, const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename scalarProduct<
Type1, Type2 >::type > > 
operator && (const UList< Type1 > &f1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename scalarProduct<
Type1, Type2 >::type > > 
operator && (const UList< Type1 > &f1, const tmp< Field< Type2 > > &tf2)
template<class Type1, class Type2>
tmp< Field< typename scalarProduct<
Type1, Type2 >::type > > 
operator && (const tmp< Field< Type1 > > &tf1, const UList< Type2 > &f2)
template<class Type1, class Type2>
tmp< Field< typename scalarProduct<
Type1, Type2 >::type > > 
operator && (const tmp< Field< Type1 > > &tf1, const tmp< Field< Type2 > > &tf2)
template<class Type, class Form, class Cmpt, int nCmpt>
void dotdot (Field< typename scalarProduct< Type, Form >::type > &f, const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename scalarProduct<
Type, Form >::type > > 
operator && (const UList< Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Type, class Form, class Cmpt, int nCmpt>
tmp< Field< typename scalarProduct<
Type, Form >::type > > 
operator && (const tmp< Field< Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<class Form, class Cmpt, int nCmpt, class Type>
void dotdot (Field< typename scalarProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename scalarProduct<
Form, Type >::type > > 
operator && (const VectorSpace< Form, Cmpt, nCmpt > &vs, const UList< Type > &f1)
template<class Form, class Cmpt, int nCmpt, class Type>
tmp< Field< typename scalarProduct<
Form, Type >::type > > 
operator && (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< Field< Type > > &tf1)


Define Documentation

#define BINARY_FUNCTION Func   ) 
 

Value:

\
template<class Type>                                                          \
void Func(Field<Type>& f, const UList<Type>& f1, const UList<Type>& f2);      \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > Func(const UList<Type>& f1, const UList<Type>& f2);         \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > Func(const UList<Type>& f1, const tmp<Field<Type> >& tf2);  \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > Func(const tmp<Field<Type> >& tf1, const UList<Type>& f2);  \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > Func                                                        \
(                                                                             \
    const tmp<Field<Type> >& tf1,                                             \
    const tmp<Field<Type> >& tf2                                              \
);                                                                            \
                                                                              \
template<class Type>                                                          \
void Func(Field<Type>& f, const UList<Type>& f1, const Type& s);              \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > Func(const UList<Type>& f1, const Type& s);                 \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > Func(const tmp<Field<Type> >& tf1, const Type& s);

Definition at line 141 of file FieldFunctions.H.

#define BINARY_OPERATOR_FF Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

\
template<class Type>                                                          \
void OpFunc                                                                   \
(                                                                             \
    Field<Type>& f,                                                           \
    const UList<Type1>& f1,                                                   \
    const UList<Type2>& f2                                                    \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const UList<Type1>& f1,                                                   \
    const UList<Type2>& f2                                                    \
);

Definition at line 271 of file FieldFunctions.H.

#define BINARY_OPERATOR_FR Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const UList<Type1>& f1,                                                   \
    const tmp<Field<Type2> >& tf2                                             \
);

Definition at line 289 of file FieldFunctions.H.

#define BINARY_OPERATOR_FT Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const UList<Type1>& f1,                                                   \
    const tmp<Field<Type2> >& tf2                                             \
);

Definition at line 297 of file FieldFunctions.H.

#define BINARY_OPERATOR_NR Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

BINARY_OPERATOR_FF(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_FR(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_TF(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_TR(Type1, Type2, Op, OpFunc)

Definition at line 349 of file FieldFunctions.H.

#define BINARY_OPERATOR_RF Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const tmp<Field<Type1> >& tf1,                                            \
    const UList<Type2>& f2                                                    \
);

Definition at line 305 of file FieldFunctions.H.

#define BINARY_OPERATOR_RN Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

BINARY_OPERATOR_FF(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_FT(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_RF(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_RT(Type1, Type2, Op, OpFunc)

Definition at line 343 of file FieldFunctions.H.

#define BINARY_OPERATOR_RR Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

BINARY_OPERATOR_FF(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_FR(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_RF(Type1, Type2, Op, OpFunc)                              \
    BINARY_OPERATOR_RT(Type1, Type2, Op, OpFunc)

Definition at line 337 of file FieldFunctions.H.

#define BINARY_OPERATOR_RT Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const tmp<Field<Type1> >& tf1,                                            \
    const tmp<Field<Type2> >& tf2                                             \
);

Definition at line 321 of file FieldFunctions.H.

#define BINARY_OPERATOR_TF Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const tmp<Field<Type1> >& tf1,                                            \
    const UList<Type2>& f2                                                    \
);

Definition at line 313 of file FieldFunctions.H.

#define BINARY_OPERATOR_TR Type1,
Type2,
Op,
OpFunc   ) 
 

Value:

template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const tmp<Field<Type1> >& tf1,                                            \
    const tmp<Field<Type2> >& tf2                                             \
);

Definition at line 329 of file FieldFunctions.H.

#define BINARY_TYPE_OPERATOR TYPE,
Op,
OpFunc   ) 
 

Value:

BINARY_TYPE_OPERATOR_SF(TYPE, Op, OpFunc)                                 \
    BINARY_TYPE_OPERATOR_FS(TYPE, Op, OpFunc)

Definition at line 425 of file FieldFunctions.H.

#define BINARY_TYPE_OPERATOR_FS TYPE,
Op,
OpFunc   ) 
 

Value:

\
template<class Type>                                                          \
void OpFunc                                                                   \
(                                                                             \
    Field<Type>& f,                                                           \
    const UList<Type>& f1,                                                    \
    const TYPE& s                                                             \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const UList<Type>& f1,                                                    \
    const TYPE& s                                                             \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const tmp<Field<Type> >& tf1,                                             \
    const TYPE& s                                                             \
);

Definition at line 400 of file FieldFunctions.H.

#define BINARY_TYPE_OPERATOR_SF TYPE,
Op,
OpFunc   ) 
 

Value:

\
template<class Type>                                                          \
void OpFunc                                                                   \
(                                                                             \
    Field<Type>& f,                                                           \
    const TYPE& s,                                                            \
    const UList<Type>& f1                                                     \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const TYPE& s,                                                            \
    const UList<Type>& f1                                                     \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const TYPE& s,                                                            \
    const tmp<Field<Type> >& tf1                                              \
);

Definition at line 375 of file FieldFunctions.H.

#define G_UNARY_FUNCTION ReturnType,
gFunc,
Func,
rFunc   ) 
 

Value:

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

Definition at line 218 of file FieldFunctions.H.

#define PRODUCT_OPERATOR product,
Op,
OpFunc   ) 
 

Definition at line 442 of file FieldFunctions.H.

#define TMP_UNARY_FUNCTION ReturnType,
Func   ) 
 

Value:

\
template<class Type>                                                          \
ReturnType Func(const tmp<Field<Type> >& tf1);

Definition at line 178 of file FieldFunctions.H.

#define UNARY_OPERATOR Op,
OpFunc   ) 
 

Value:

\
template<class Type>                                                          \
void OpFunc                                                                   \
(                                                                             \
    Field<Type>& f,                                                           \
    const UList<Type>& f1                                                     \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const UList<Type>& f1                                                     \
);                                                                            \
                                                                              \
template<class Type>                                                          \
tmp<Field<Type> > operator Op                                                 \
(                                                                             \
    const tmp<Field<Type> >& tf1                                              \
);

Definition at line 245 of file FieldFunctions.H.


Function Documentation

void add Field< typename typeOfSum< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

void add Field< typename typeOfSum< Type, Form >::type > &  f,
const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void add Field< typename typeOfSum< Type1, Type2 >::type > &  f,
const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

Type average const tmp< Field< Type > > &  tf1  ) 
 

Type average const UList< Type > &  f  ) 
 

tmp<Field<typename Field<Type>::cmptType> > cmptAv const tmp< Field< Type > > &  tf  ) 
 

tmp<Field<typename Field<Type>::cmptType> > cmptAv const UList< Type > &  f  ) 
 

void cmptAv Field< typename Field< Type >::cmptType > &  cf,
const UList< Type > &  f
 

tmp<Field<Type> > cmptMag const tmp< Field< Type > > &  tf  ) 
 

tmp<Field<Type> > cmptMag const UList< Type > &  f  ) 
 

void cmptMag Field< Type > &  cf,
const UList< Type > &  f
 

void component Field< typename Field< Type >::cmptType > &  sf,
const UList< Type > &  f,
const direction  d
 

void cross Field< typename crossProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

void cross Field< typename crossProduct< Type, Form >::type > &  f,
const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void cross Field< typename crossProduct< Type1, Type2 >::type > &  f,
const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

void divide Field< Type > &  f,
const UList< Type > &  f1,
const scalar &  s
 

void divide Field< Type > &  f,
const UList< Type > &  f1,
const UList< scalar > &  f2
 

void dot Field< typename innerProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

void dot Field< typename innerProduct< Type, Form >::type > &  f,
const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void dot Field< typename innerProduct< Type1, Type2 >::type > &  f,
const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

void dotdot Field< typename scalarProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

void dotdot Field< typename scalarProduct< Type, Form >::type > &  f,
const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void dotdot Field< typename scalarProduct< Type1, Type2 >::type > &  f,
const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

Type gAverage const tmp< Field< Type > > &  tf1  ) 
 

Type gAverage const UList< Type > &  f  ) 
 

Type gMax const tmp< Field< Type > > &  tf1  ) 
 

Type gMax const UList< Type > &  f  ) 
 

Type gMin const tmp< Field< Type > > &  tf1  ) 
 

Type gMin const UList< Type > &  f  ) 
 

Type gSum const tmp< Field< Type > > &  tf1  ) 
 

Referenced by if().

Type gSum const UList< Type > &  f  ) 
 

scalar gSumMag const tmp< Field< Type > > &  tf1  ) 
 

scalar gSumMag const UList< Type > &  f  ) 
 

scalar gSumProd const UList< Type > &  f1,
const UList< Type > &  f2
 

scalar gSumSqr const tmp< Field< Type > > &  tf1  ) 
 

scalar gSumSqr const UList< Type > &  f  ) 
 

tmp<Field<scalar> > mag const tmp< Field< Type > > &  tf  ) 
 

tmp<Field<scalar> > mag const UList< Type > &  f  ) 
 

void mag Field< scalar > &  sf,
const UList< Type > &  f
 

tmp<Field<scalar> > magSqr const tmp< Field< Type > > &  tf  ) 
 

tmp<Field<scalar> > magSqr const UList< Type > &  f  ) 
 

void magSqr Field< scalar > &  sf,
const UList< Type > &  f
 

Type max const tmp< Field< Type > > &  tf1  ) 
 

Type max const UList< Type > &  f  ) 
 

tmp<Field<Type> > max const tmp< Field< Type > > &  tf1,
const Type &  s
 

tmp<Field<Type> > max const UList< Type > &  f1,
const Type &  s
 

void max Field< Type > &  f,
const UList< Type > &  f1,
const Type &  s
 

tmp<Field<Type> > max const tmp< Field< Type > > &  tf1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > max const tmp< Field< Type > > &  tf1,
const UList< Type > &  f2
 

tmp<Field<Type> > max const UList< Type > &  f1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > max const UList< Type > &  f1,
const UList< Type > &  f2
 

void max Field< Type > &  f,
const UList< Type > &  f1,
const UList< Type > &  f2
 

Type min const tmp< Field< Type > > &  tf1  ) 
 

Type min const UList< Type > &  f  ) 
 

tmp<Field<Type> > min const tmp< Field< Type > > &  tf1,
const Type &  s
 

tmp<Field<Type> > min const UList< Type > &  f1,
const Type &  s
 

void min Field< Type > &  f,
const UList< Type > &  f1,
const Type &  s
 

tmp<Field<Type> > min const tmp< Field< Type > > &  tf1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > min const tmp< Field< Type > > &  tf1,
const UList< Type > &  f2
 

tmp<Field<Type> > min const UList< Type > &  f1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > min const UList< Type > &  f1,
const UList< Type > &  f2
 

void min Field< Type > &  f,
const UList< Type > &  f1,
const UList< Type > &  f2
 

void multiply Field< Type > &  f,
const UList< Type > &  f1,
const scalar &  s
 

void multiply Field< Type > &  f,
const scalar &  s,
const UList< Type > &  f1
 

void multiply Field< Type > &  f,
const UList< scalar > &  f1,
const UList< Type > &  f2
 

void multiply Field< Type > &  f,
const UList< Type > &  f1,
const UList< scalar > &  f2
 

void negate Field< Type > &  f,
const UList< Type > &  f1
 

tmp<Field<typename innerProduct <Form, Type>::type> > operator & const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< Field< Type > > &  tf1
 

tmp<Field<typename innerProduct <Form, Type>::type> > operator & const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

tmp<Field<typename innerProduct <Type, Form>::type> > operator & const tmp< Field< Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename innerProduct <Type, Form>::type> > operator & const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename innerProduct <Type1, Type2>::type> > operator & const tmp< Field< Type1 > > &  tf1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename innerProduct <Type1, Type2>::type> > operator & const tmp< Field< Type1 > > &  tf1,
const UList< Type2 > &  f2
 

tmp<Field<typename innerProduct <Type1, Type2>::type> > operator & const UList< Type1 > &  f1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename innerProduct <Type1, Type2>::type> > operator & const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

tmp<Field<typename scalarProduct <Form, Type>::type> > operator && const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< Field< Type > > &  tf1
 

tmp<Field<typename scalarProduct <Form, Type>::type> > operator && const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

tmp<Field<typename scalarProduct <Type, Form>::type> > operator && const tmp< Field< Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename scalarProduct <Type, Form>::type> > operator && const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename scalarProduct <Type1, Type2>::type> > operator && const tmp< Field< Type1 > > &  tf1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename scalarProduct <Type1, Type2>::type> > operator && const tmp< Field< Type1 > > &  tf1,
const UList< Type2 > &  f2
 

tmp<Field<typename scalarProduct <Type1, Type2>::type> > operator && const UList< Type1 > &  f1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename scalarProduct <Type1, Type2>::type> > operator && const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

tmp<Field<typename outerProduct <Form, Type>::type> > operator * const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< Field< Type > > &  tf1
 

tmp<Field<typename outerProduct <Form, Type>::type> > operator * const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

tmp<Field<typename outerProduct <Type, Form>::type> > operator * const tmp< Field< Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename outerProduct <Type, Form>::type> > operator * const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename outerProduct <Type1, Type2>::type> > operator * const tmp< Field< Type1 > > &  tf1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename outerProduct <Type1, Type2>::type> > operator * const tmp< Field< Type1 > > &  tf1,
const UList< Type2 > &  f2
 

tmp<Field<typename outerProduct <Type1, Type2>::type> > operator * const UList< Type1 > &  f1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename outerProduct <Type1, Type2>::type> > operator * const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

tmp<Field<Type> > operator * const tmp< Field< Type > > &  tf1,
const scalar &  s
 

tmp<Field<Type> > operator * const UList< Type > &  f1,
const scalar &  s
 

tmp<Field<Type> > operator * const scalar &  s,
const tmp< Field< Type > > &  tf1
 

tmp<Field<Type> > operator * const scalar &  s,
const UList< Type > &  f1
 

tmp<Field<Type> > operator * const tmp< Field< scalar > > &  tf1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > operator * const tmp< Field< scalar > > &  tf1,
const UList< Type > &  f2
 

tmp<Field<Type> > operator * const UList< scalar > &  f1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > operator * const UList< scalar > &  f1,
const UList< Type > &  f2
 

tmp<Field<Type> > operator * const tmp< Field< Type > > &  tf1,
const tmp< Field< scalar > > &  tf2
 

tmp<Field<Type> > operator * const tmp< Field< Type > > &  tf1,
const UList< scalar > &  f2
 

tmp<Field<Type> > operator * const UList< Type > &  f1,
const tmp< Field< scalar > > &  tf2
 

tmp<Field<Type> > operator * const UList< Type > &  f1,
const UList< scalar > &  f2
 

tmp<Field<typename typeOfSum <Form, Type>::type> > operator+ const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< Field< Type > > &  tf1
 

tmp<Field<typename typeOfSum <Form, Type>::type> > operator+ const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

tmp<Field<typename typeOfSum <Type, Form>::type> > operator+ const tmp< Field< Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename typeOfSum <Type, Form>::type> > operator+ const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator+ const tmp< Field< Type1 > > &  tf1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator+ const tmp< Field< Type1 > > &  tf1,
const UList< Type2 > &  f2
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator+ const UList< Type1 > &  f1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator+ const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

tmp<Field<typename typeOfSum <Form, Type>::type> > operator- const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< Field< Type > > &  tf1
 

tmp<Field<typename typeOfSum <Form, Type>::type> > operator- const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

tmp<Field<typename typeOfSum <Type, Form>::type> > operator- const tmp< Field< Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename typeOfSum <Type, Form>::type> > operator- const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator- const tmp< Field< Type1 > > &  tf1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator- const tmp< Field< Type1 > > &  tf1,
const UList< Type2 > &  f2
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator- const UList< Type1 > &  f1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename typeOfSum <Type1, Type2>::type> > operator- const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

tmp<Field<Type> > operator- const tmp< Field< Type > > &  tf1  ) 
 

tmp<Field<Type> > operator- const UList< Type > &  f1  ) 
 

tmp<Field<Type> > operator/ const tmp< Field< Type > > &  tf1,
const scalar &  s
 

tmp<Field<Type> > operator/ const UList< Type > &  f1,
const scalar &  s
 

tmp<Field<Type> > operator/ const tmp< Field< Type > > &  tf1,
const tmp< Field< scalar > > &  tf2
 

tmp<Field<Type> > operator/ const tmp< Field< Type > > &  tf1,
const UList< scalar > &  f2
 

tmp<Field<Type> > operator/ const UList< Type > &  f1,
const tmp< Field< scalar > > &  tf2
 

tmp<Field<Type> > operator/ const UList< Type > &  f1,
const UList< scalar > &  f2
 

tmp<Field<typename crossProduct <Form, Type>::type> > operator^ const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< Field< Type > > &  tf1
 

tmp<Field<typename crossProduct <Form, Type>::type> > operator^ const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

tmp<Field<typename crossProduct <Type, Form>::type> > operator^ const tmp< Field< Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename crossProduct <Type, Form>::type> > operator^ const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<Field<typename crossProduct <Type1, Type2>::type> > operator^ const tmp< Field< Type1 > > &  tf1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename crossProduct <Type1, Type2>::type> > operator^ const tmp< Field< Type1 > > &  tf1,
const UList< Type2 > &  f2
 

tmp<Field<typename crossProduct <Type1, Type2>::type> > operator^ const UList< Type1 > &  f1,
const tmp< Field< Type2 > > &  tf2
 

tmp<Field<typename crossProduct <Type1, Type2>::type> > operator^ const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

void outer Field< typename outerProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

void outer Field< typename outerProduct< Type, Form >::type > &  f,
const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void outer Field< typename outerProduct< Type1, Type2 >::type > &  f,
const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

tmp<Field<typename powProduct<Type, r>::type> > pow const tmp< Field< Type > > &  tf,
typename powProduct< Type, r >::type  = pTraits< typename powProduct< Type, r >::type >::zero
 

tmp<Field<typename powProduct<Type, r>::type> > pow const UList< Type > &  f,
typename powProduct< Type, r >::type  = pTraits< typename powProduct< Type, r >::type >::zero
 

void pow Field< typename powProduct< Type, r >::type > &  f,
const UList< Type > &  vf
 

tmp<Field<Type> > scale const tmp< Field< Type > > &  tf1,
const Type &  s
 

tmp<Field<Type> > scale const UList< Type > &  f1,
const Type &  s
 

void scale Field< Type > &  f,
const UList< Type > &  f1,
const Type &  s
 

tmp<Field<Type> > scale const tmp< Field< Type > > &  tf1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > scale const tmp< Field< Type > > &  tf1,
const UList< Type > &  f2
 

tmp<Field<Type> > scale const UList< Type > &  f1,
const tmp< Field< Type > > &  tf2
 

tmp<Field<Type> > scale const UList< Type > &  f1,
const UList< Type > &  f2
 

void scale Field< Type > &  f,
const UList< Type > &  f1,
const UList< Type > &  f2
 

tmp<Field<typename outerProduct<Type, Type>::type> > sqr const tmp< Field< Type > > &  tf  ) 
 

tmp<Field<typename outerProduct<Type, Type>::type> > sqr const UList< Type > &  f  ) 
 

void sqr Field< typename outerProduct< Type, Type >::type > &  f,
const UList< Type > &  vf
 

void subtract Field< typename typeOfSum< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const UList< Type > &  f1
 

void subtract Field< typename typeOfSum< Type, Form >::type > &  f,
const UList< Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void subtract Field< typename typeOfSum< Type1, Type2 >::type > &  f,
const UList< Type1 > &  f1,
const UList< Type2 > &  f2
 

Type sum const tmp< Field< Type > > &  tf1  ) 
 

Type sum const UList< Type > &  f  ) 
 

scalar sumMag const tmp< Field< Type > > &  tf1  ) 
 

scalar sumMag const UList< Type > &  f  ) 
 

scalar sumProd const UList< Type > &  f1,
const UList< Type > &  f2
 

scalar sumSqr const tmp< Field< Type > > &  tf1  ) 
 

scalar sumSqr const UList< Type > &  f  ) 
 

void T Field< Type > &  f1,
const UList< Type > &  f2
 

For further information go to www.openfoam.org