FieldFunctionsM.H File Reference

High performance macro functions for Field<Type> algebra. These expand using either array element access (for vector machines) or pointer dereferencing for scalar machines as appropriate. More...

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

Go to the source code of this file.

Macros
#define	UNARY_FUNCTION(ReturnType, Type1, Func)
#define	UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc)
#define	BINARY_FUNCTION(ReturnType, Type1, Type2, Func)
#define	BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)
#define	BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
#define	BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)
#define	BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc)
#define	BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc)
#define	BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
#define	BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc)

Detailed Description

High performance macro functions for Field<Type> algebra. These expand using either array element access (for vector machines) or pointer dereferencing for scalar machines as appropriate.

Original source file FieldFunctionsM.H

Definition in file FieldFunctionsM.H.

Macro Definition Documentation

UNARY_FUNCTION

#define UNARY_FUNCTION	(		ReturnType,
			Type1,
			Func
	)

Value:

                                                                               \
TEMPLATE                                                                       \
void Func(Field<ReturnType>& res, const UList<Type1>& f);                      \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> Func(const UList<Type1>& f);                            \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf);

Definition at line 29 of file FieldFunctionsM.H.

UNARY_OPERATOR

#define UNARY_OPERATOR	(		ReturnType,
			Type1,
			Op,
			OpFunc
	)

Value:

                                                                               \
TEMPLATE                                                                       \
void OpFunc(Field<ReturnType>& res, const UList<Type1>& f);                    \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> operator Op(const UList<Type1>& f);                     \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> operator Op(const tmp<Field<Type1>>& tf);

Definition at line 41 of file FieldFunctionsM.H.

BINARY_FUNCTION

#define BINARY_FUNCTION	(		ReturnType,
			Type1,
			Type2,
			Func
	)

Definition at line 53 of file FieldFunctionsM.H.

BINARY_TYPE_FUNCTION_SF

#define BINARY_TYPE_FUNCTION_SF	(		ReturnType,
			Type1,
			Type2,
			Func
	)

Value:

                                                                               \
TEMPLATE                                                                       \
void Func                                                                      \
(                                                                              \
    Field<ReturnType>& f,                                                      \
    const Type1& s1,                                                           \
    const UList<Type2>& f2                                                     \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> Func                                                    \
(                                                                              \
    const Type1& s1,                                                           \
    const UList<Type2>& f2                                                     \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> Func                                                    \
(                                                                              \
    const Type1& s1,                                                           \
    const tmp<Field<Type2>>& tf2                                               \
);

Definition at line 94 of file FieldFunctionsM.H.

BINARY_TYPE_FUNCTION_FS

#define BINARY_TYPE_FUNCTION_FS	(		ReturnType,
			Type1,
			Type2,
			Func
	)

Value:

                                                                               \
TEMPLATE                                                                       \
void Func                                                                      \
(                                                                              \
    Field<ReturnType>& f,                                                      \
    const UList<Type1>& f1,                                                    \
    const Type2& s2                                                            \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> Func                                                    \
(                                                                              \
    const UList<Type1>& f1,                                                    \
    const Type2& s2                                                            \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> Func                                                    \
(                                                                              \
    const tmp<Field<Type1>>& tf1,                                              \
    const Type2& s2                                                            \
);

Definition at line 119 of file FieldFunctionsM.H.

BINARY_TYPE_FUNCTION

#define BINARY_TYPE_FUNCTION	(		ReturnType,
			Type1,
			Type2,
			Func
	)

Value:

    BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                    \
    BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)

Definition at line 144 of file FieldFunctionsM.H.

BINARY_OPERATOR

#define BINARY_OPERATOR	(		ReturnType,
			Type1,
			Type2,
			Op,
			OpFunc
	)

Definition at line 151 of file FieldFunctionsM.H.

BINARY_TYPE_OPERATOR_SF

#define BINARY_TYPE_OPERATOR_SF	(		ReturnType,
			Type1,
			Type2,
			Op,
			OpFunc
	)

Value:

                                                                               \
TEMPLATE                                                                       \
void OpFunc                                                                    \
(                                                                              \
    Field<ReturnType>& f,                                                      \
    const Type1& s1,                                                           \
    const UList<Type2>& f2                                                     \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> operator Op                                             \
(                                                                              \
    const Type1& s1,                                                           \
    const UList<Type2>& f2                                                     \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> operator Op                                             \
(                                                                              \
    const Type1& s1,                                                           \
    const tmp<Field<Type2>>& tf2                                               \
);

Definition at line 192 of file FieldFunctionsM.H.

BINARY_TYPE_OPERATOR_FS

#define BINARY_TYPE_OPERATOR_FS	(		ReturnType,
			Type1,
			Type2,
			Op,
			OpFunc
	)

Value:

                                                                               \
TEMPLATE                                                                       \
void OpFunc                                                                    \
(                                                                              \
    Field<ReturnType>& f,                                                      \
    const UList<Type1>& f1,                                                    \
    const Type2& s2                                                            \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> operator Op                                             \
(                                                                              \
    const UList<Type1>& f1,                                                    \
    const Type2& s2                                                            \
);                                                                             \
                                                                               \
TEMPLATE                                                                       \
tmp<Field<ReturnType>> operator Op                                             \
(                                                                              \
    const tmp<Field<Type1>>& tf1,                                              \
    const Type2& s2                                                            \
);

Definition at line 217 of file FieldFunctionsM.H.

BINARY_TYPE_OPERATOR

#define BINARY_TYPE_OPERATOR	(		ReturnType,
			Type1,
			Type2,
			Op,
			OpFunc
	)

Value:

    BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc)              \
    BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)

Definition at line 242 of file FieldFunctionsM.H.