plain_def.h File Reference

macros for composing plain loops over arrays. More...

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

Go to the source code of this file.

Defines

#define LCTYPE(T)   register typename tbci_traits<T>::loop_const_refval_type
 Shortcut for loop const ref type.
#define LCTYPED(T)   register tbci_traits<T>::loop_const_refval_type
#define VKERN_TEMPL_3V(FNAME, OP3)
 We leave unrolling and prefetching to the compiler.
#define VKERN_TEMPL_3V_C(FNAME, OP3)
 Operations of type vec = vec OP val * vec.
#define VKERN_TEMPL_3V_CC(FNAME, OP3)
 Operations of type vec = val * vec OP val * vec.
#define VKERN_TEMPL_2V(FNAME, OP2)
 Operations of type vec OP= vec.
#define VKERN_TEMPL_2V_C(FNAME, OP2)
 Operations of type VEC = VEC OP VAL or VAL OP VEC.
#define VKERN_TEMPL_2V_CC(FNAME, OP2)
 Operations of type VEC = VEC OP VAL or VAL OP VEC.
#define VKERN_TEMPL_2V_T(FNAME, OP2, TYPE)
 Operations of type TYPE = VEC OP VEC.
#define VKERN_TEMPL_1V(FNAME, OP1)
 Operations of type VEC = OP self.
#define VKERN_TEMPL_1V_C(FNAME, OP1)
 Operations of type VEC OP= VAL.
#define VKERN_TEMPL_1V_CC(FNAME, OP1)
 Operations of type VEC *= S OP= VAL.
#define VKERN_TEMPL_1V_T(FNAME, OP1, TYPE)
 Operations of type TYPE = OP VEC.


Detailed Description

macros for composing plain loops over arrays.

(c) Kurt Garloff, <kurt@garloff.de>, 7/2002, GNU LGPL v2

Id
plain_def.h,v 1.1.2.9 2005/04/21 09:35:24 garloff Exp

Definition in file plain_def.h.


Define Documentation

#define LCTYPE (  )     register typename tbci_traits<T>::loop_const_refval_type

Shortcut for loop const ref type.

Definition at line 13 of file plain_def.h.

#define LCTYPED (  )     register tbci_traits<T>::loop_const_refval_type

Definition at line 14 of file plain_def.h.

#define VKERN_TEMPL_1V ( FNAME,
OP1   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const);)      \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res)           \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP1(res[i], f1, f2);                    \
}
Operations of type VEC = OP self.

Definition at line 137 of file plain_def.h.

#define VKERN_TEMPL_1V_C ( FNAME,
OP1   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const, LCTYPED(T));) \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       LCTYPE(T) f2)                    \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP1(res[i], f1, f2);                    \
}
Operations of type VEC OP= VAL.

Definition at line 150 of file plain_def.h.

#define VKERN_TEMPL_1V_CC ( FNAME,
OP1   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const,        \
         LCTYPED(T), LCTYPED(T));)                      \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       LCTYPE(T) f1,                    \
                       LCTYPE(T) f2)                    \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP1(res[i], f1, f2);                    \
}
Operations of type VEC *= S OP= VAL.

Definition at line 164 of file plain_def.h.

#define VKERN_TEMPL_1V_T ( FNAME,
OP1,
TYPE   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, const T*, TYPE&);)        \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       const T* res,                    \
                       TYPE &_f2)                       \
{                                                       \
        register typename tbci_traits<TYPE>::loop_refval_type f2(_f2);  \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP1(res[i], f1, f2);                    \
        _f2 = f2;                                       \
}
Operations of type TYPE = OP VEC.

Definition at line 180 of file plain_def.h.

#define VKERN_TEMPL_2V ( FNAME,
OP2   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const, const T* RESTRICT const);) \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       const T* RESTRICT const v1)      \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP2(res[i], v1[i], f1, f2);             \
}
Operations of type vec OP= vec.

Definition at line 72 of file plain_def.h.

#define VKERN_TEMPL_2V_C ( FNAME,
OP2   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const, const T* RESTRICT const, \
         LCTYPED(T));)                                  \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       const T* RESTRICT const v1,      \
                       LCTYPE(T) f2)                    \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP2(res[i], v1[i], f1, f2);             \
}
Operations of type VEC = VEC OP VAL or VAL OP VEC.

Definition at line 86 of file plain_def.h.

#define VKERN_TEMPL_2V_CC ( FNAME,
OP2   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const, const T* RESTRICT const, \
         LCTYPED(T), LCTYPED(T));)                              \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       const T* RESTRICT const v1,      \
                       LCTYPE(T) f1,                    \
                       LCTYPE(T) f2)                    \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP2(res[i], v1[i], f1, f2);             \
}
Operations of type VEC = VEC OP VAL or VAL OP VEC.

Definition at line 102 of file plain_def.h.

#define VKERN_TEMPL_2V_T ( FNAME,
OP2,
TYPE   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, const T* RESTRICT const,  \
         const T* RESTRICT const, TYPE&);)              \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       const T* RESTRICT const v1,      \
                       const T* RESTRICT const v2,      \
                       TYPE &_f2)                       \
{                                                       \
        register typename tbci_traits<TYPE>::loop_refval_type f2(_f2);  \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP2(v1[i], v2[i], f1, f2);              \
        _f2 = f2;                                       \
}
Operations of type TYPE = VEC OP VEC.

Definition at line 119 of file plain_def.h.

#define VKERN_TEMPL_3V ( FNAME,
OP3   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME \
        (const unsigned long, T* RESTRICT const, const T* RESTRICT const, \
         const T* RESTRICT const);)                     \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       const T* RESTRICT const v1,      \
                       const T* RESTRICT const v2)      \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP3(res[i], v1[i], v2[i], f1, f2);      \
}
We leave unrolling and prefetching to the compiler.

Operations of type vec = vec OP vec

Definition at line 21 of file plain_def.h.

#define VKERN_TEMPL_3V_C ( FNAME,
OP3   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME   \
        (const unsigned long, T* RESTRICT const, const T* RESTRICT const, \
         const T* RESTRICT const, LCTYPED(T));)         \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       const T* RESTRICT const v1,      \
                       const T* RESTRICT const v2,      \
                       LCTYPE(T) f2)                    \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP3(res[i], v1[i], v2[i], f1, f2);      \
}
Operations of type vec = vec OP val * vec.

Definition at line 37 of file plain_def.h.

#define VKERN_TEMPL_3V_CC ( FNAME,
OP3   ) 

Value:

INST(template <typename T> class Vector<T> friend VEC_INLINE void FNAME   \
        (const unsigned long, T* RESTRICT const, const T* RESTRICT const, \
         const T* RESTRICT const, LCTYPED(T), LCTYPED(T));)     \
template <typename T>                                   \
VEC_INLINE void FNAME (const unsigned long sz,          \
                       T* RESTRICT const res,           \
                       const T* RESTRICT const v1,      \
                       const T* RESTRICT const v2,      \
                       LCTYPE(T) f1,                    \
                       LCTYPE(T) f2)                    \
{                                                       \
        register unsigned long i;                       \
        for (i = 0; i < sz; ++i)                        \
                OP3(res[i], v1[i], v2[i], f1, f2);      \
}
Operations of type vec = val * vec OP val * vec.

Definition at line 54 of file plain_def.h.


Generated on Wed Nov 20 09:28:25 2013 for TBCI Numerical high perf. C++ Library by  doxygen 1.5.6