ListExpression.H File Reference

Expression templates for List. More...

Include dependency graph for ListExpression.H:

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

Go to the source code of this file.

Classes
class	ListExpression< E >
	Expression templates for List. More...
class	ListWrap< T >
	Expression wrap of a List. More...
class	ListRefWrap< T >
	Expression wrap of non-const reference to List. More...
class	ListConstRefWrap< T >
	Expression wrap of const reference to UList. More...
struct	ListConstRefWrap< T >::const_iterator
class	ListTmpWrap< T >
	Expression wrap of tmp to List. More...
class	ListConstTmpWrap< T >
	Expression wrap of const tmp to List. More...
struct	ListConstTmpWrap< T >::const_iterator
	Define our own iterator so we can refer to it. 'normal', e.g. double*. More...
class	IndirectConstWrap< E1 >
	Expression wrap of indirection. More...
struct	IndirectConstWrap< E1 >::const_iterator
class	List_negate< E1 >
	List negation. More...
struct	List_negate< E1 >::const_iterator
class	List_sin< E1 >
	Expression wrapping function for unary sin function. More...
struct	List_sin< E1 >::const_iterator
class	List_cos< E1 >
	Expression wrapping function for unary cos function. More...
struct	List_cos< E1 >::const_iterator
class	List_tan< E1 >
	Expression wrapping function for unary tan function. More...
struct	List_tan< E1 >::const_iterator
class	List_sinh< E1 >
	Expression wrapping function for unary sinh function. More...
struct	List_sinh< E1 >::const_iterator
class	List_cosh< E1 >
	Expression wrapping function for unary cosh function. More...
struct	List_cosh< E1 >::const_iterator
class	List_tanh< E1 >
	Expression wrapping function for unary tanh function. More...
struct	List_tanh< E1 >::const_iterator
class	List_sqr< E1 >
	Expression wrapping function for unary sqr function. More...
struct	List_sqr< E1 >::const_iterator
class	List_sqrt< E1 >
	Expression wrapping function for unary sqrt function. More...
struct	List_sqrt< E1 >::const_iterator
class	List_magSqr< E1 >
	Expression wrapping function for unary magSqr function. More...
struct	List_magSqr< E1 >::const_iterator
class	List_mag< E1 >
	Expression wrapping function for unary mag function. More...
struct	List_mag< E1 >::const_iterator
class	List_symm< E1 >
	Expression wrapping function for unary symm function. More...
struct	List_symm< E1 >::const_iterator
class	List_pow2< E1 >
	Expression wrapping function for unary pow2 function. More...
struct	List_pow2< E1 >::const_iterator
class	List_pow3< E1 >
	Expression wrapping function for unary pow3 function. More...
struct	List_pow3< E1 >::const_iterator
class	List_pow4< E1 >
	Expression wrapping function for unary pow4 function. More...
struct	List_pow4< E1 >::const_iterator
class	List_min< E1, E2 >
	Expression wrapping function for binary min function. More...
struct	List_min< E1, E2 >::const_iterator
class	List_max< E1, E2 >
	Expression wrapping function for binary max function. More...
struct	List_max< E1, E2 >::const_iterator
class	List_add< E1, E2 >
	List operators. More...
struct	List_add< E1, E2 >::const_iterator
class	List_subtract< E1, E2 >
struct	List_subtract< E1, E2 >::const_iterator
class	List_multiply< E1, E2 >
struct	List_multiply< E1, E2 >::const_iterator
class	List_divide< E1, E2 >
struct	List_divide< E1, E2 >::const_iterator
class	List_dot< E1, E2 >
struct	List_dot< E1, E2 >::const_iterator
class	List_interpolate< E1, E2, E3 >
	Not possible: a *= b has to return a new type so it can never be in-place. More...
struct	List_interpolate< E1, E2, E3 >::const_iterator
class	UniformListWrap< T >
	Expression wrap of a List with a uniform value. More...
struct	UniformListWrap< T >::const_iterator
class	UniformListWrap2< T >
	Expression wrap of a uniform value without a List size. More...
struct	UniformListWrap2< T >::const_iterator
class	ListsConstRefWrap< V >
	Expression wrap of multiple lists (e.g. FieldField). More...
struct	ListsConstRefWrap< V >::const_iterator
class	ListsRefWrap< V >
	Expression wrap of multiple lists. More...
struct	ListsRefWrap< V >::const_iterator
struct	ListsRefWrap< V >::iterator

Namespaces
namespace	Foam
	Namespace for OpenFOAM.
namespace	Foam::Expression
	A namespace for expression templates.

Macros
#define	Foam_Expression_execution
#define	EXPRESSION_FUNCTION1(Func, BaseFunc, OpFunc)
#define	EXPRESSION_FUNCTION2(Func, BaseFunc, OpFunc)
#define	EXPRESSION_OPERATOR(Op, OpFunc)

Functions
template<typename E1>
auto	operator- (const ListExpression< E1 > &u)
template<class Type>
auto	operator- (UList< Type > const &u)
template<typename E1>
auto	sin (const ListExpression< E1 > &u)
template<class Type>
auto	sin (UList< Type > const &u)
template<typename E1>
auto	cos (const ListExpression< E1 > &u)
template<class Type>
auto	cos (UList< Type > const &u)
template<typename E1>
auto	tan (const ListExpression< E1 > &u)
template<class Type>
auto	tan (UList< Type > const &u)
template<typename E1>
auto	sinh (const ListExpression< E1 > &u)
template<class Type>
auto	sinh (UList< Type > const &u)
template<typename E1>
auto	cosh (const ListExpression< E1 > &u)
template<class Type>
auto	cosh (UList< Type > const &u)
template<typename E1>
auto	tanh (const ListExpression< E1 > &u)
template<class Type>
auto	tanh (UList< Type > const &u)
template<typename E1>
auto	sqr (const ListExpression< E1 > &u)
template<class Type>
auto	sqr (UList< Type > const &u)
template<typename E1>
auto	sqrt (const ListExpression< E1 > &u)
template<class Type>
auto	sqrt (UList< Type > const &u)
template<typename E1>
auto	magSqr (const ListExpression< E1 > &u)
template<class Type>
auto	magSqr (UList< Type > const &u)
template<typename E1>
auto	mag (const ListExpression< E1 > &u)
template<class Type>
auto	mag (UList< Type > const &u)
template<typename E1>
auto	symm (const ListExpression< E1 > &u)
template<class Type>
auto	symm (UList< Type > const &u)
template<typename E1>
auto	pow2 (const ListExpression< E1 > &u)
template<class Type>
auto	pow2 (UList< Type > const &u)
template<typename E1>
auto	pow3 (const ListExpression< E1 > &u)
template<class Type>
auto	pow3 (UList< Type > const &u)
template<typename E1>
auto	pow4 (const ListExpression< E1 > &u)
template<class Type>
auto	pow4 (UList< Type > const &u)
template<typename E1, typename E2>
auto	min (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	min (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	min (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	min (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	min (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	min (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	min (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	min (TypeT const &u, UList< Type > const &v)
template<typename E1, typename E2>
auto	max (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	max (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	max (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	max (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	max (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	max (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	max (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	max (TypeT const &u, UList< Type > const &v)
template<typename E1, typename E2>
auto	operator+ (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	operator+ (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	operator+ (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	operator+ (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator+ (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator+ (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator+ (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator+ (TypeT const &u, UList< Type > const &v)
template<typename E1, typename E2>
auto	operator- (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	operator- (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	operator- (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	operator- (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator- (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator- (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator- (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator- (TypeT const &u, UList< Type > const &v)
template<typename E1, typename E2>
auto	operator* (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	operator* (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	operator* (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	operator* (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator* (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator* (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator* (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator* (TypeT const &u, UList< Type > const &v)
template<typename E1, typename E2>
auto	operator/ (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	operator/ (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	operator/ (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	operator/ (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator/ (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator/ (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator/ (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator/ (TypeT const &u, UList< Type > const &v)
template<typename E1, typename E2>
auto	operator& (ListExpression< E1 > const &u, ListExpression< E2 > const &v)
template<typename E1, class Type>
auto	operator& (ListExpression< E1 > const &u, UList< Type > const &v)
template<typename E1, class Type>
auto	operator& (UList< Type > const &u, ListExpression< E1 > const &v)
template<class Type1, class Type2>
auto	operator& (UList< Type1 > const &u, UList< Type2 > const &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator& (ListExpression< E1 > const &u, const Type &v)
template<typename E1, class Type, class = std::enable_if_t < (std::is_arithmetic_v<Type> || Foam::is_vectorspace_v<Type>) >>
auto	operator& (const Type &u, ListExpression< E1 > const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator& (UList< Type > const &u, TypeT const &v)
template<class Type, class TypeT = Type, class = std::enable_if_t < (std::is_arithmetic_v<TypeT> || Foam::is_vectorspace_v<TypeT>) >>
auto	operator& (TypeT const &u, UList< Type > const &v)

Detailed Description

Expression templates for List.

Original source file ListExpression.H

InNamespace Foam::Expression

Source files

• ListExpression.H
• ListExpression.H

Definition in file ListExpression.H.

Macro Definition Documentation

Foam_Expression_execution

#define Foam_Expression_execution

Definition at line 39 of file ListExpression.H.

EXPRESSION_FUNCTION1

#define EXPRESSION_FUNCTION1	(		Func,
			BaseFunc,
			OpFunc )

Definition at line 956 of file ListExpression.H.

EXPRESSION_FUNCTION2

#define EXPRESSION_FUNCTION2	(		Func,
			BaseFunc,
			OpFunc )

Definition at line 1241 of file ListExpression.H.

EXPRESSION_OPERATOR

#define EXPRESSION_OPERATOR	(		Op,
			OpFunc )

Definition at line 1466 of file ListExpression.H.