newet-macros.h

著名的数学计算类库

                                                                          \
template<typename T1, typename T2>                                        \
_bz_inline_et                                                             \
_bz_ArrayExpr<_bz_ArrayExprBinaryOp<                                      \
    _bz_typename asExpr<T1>::T_expr,                                      \
    _bz_typename asExpr<T2>::T_expr,                                      \
    applic<_bz_typename asExpr<T1>::T_expr::T_numtype,                    \
           _bz_typename asExpr<T2>::T_expr::T_numtype> > >                \
name(const ETBase<T1>& d1, const ETBase<T2>& d2)                          \
{                                                                         \
    return _bz_ArrayExpr<_bz_ArrayExprBinaryOp<                           \
        _bz_typename asExpr<T1>::T_expr,                                  \
        _bz_typename asExpr<T2>::T_expr,                                  \
        applic<_bz_typename asExpr<T1>::T_expr::T_numtype,                \
               _bz_typename asExpr<T2>::T_expr::T_numtype> > >            \
        (asExpr<T1>::getExpr(d1.unwrap()),                                \
         asExpr<T2>::getExpr(d2.unwrap()));                               \
}

#define BZ_DECLARE_ARRAY_ET_BINARY_TINYVEC(name, applic)                  \
                                                                          \
template <typename T1, typename T2, int N>                                \
_bz_inline_et                                                             \
_bz_ArrayExprBinaryOp<                                                    \
    _bz_typename asExpr<TinyVector<T2,N> >::T_expr,                       \
    _bz_typename asExpr<T1>::T_expr,                                      \
    applic<TinyVector<T2,N>,                                              \
    _bz_typename asExpr<T1>::T_expr::T_numtype> >                         \
name(const TinyVector<T2,N> d1, const ETBase<T1>& d2)                     \
{                                                                         \
    return _bz_ArrayExprBinaryOp<                                         \
        _bz_typename asExpr<TinyVector<T2,N> >::T_expr,                   \
        _bz_typename asExpr<T1>::T_expr,                                  \
        applic<TinyVector<T2,N>,                                          \
        _bz_typename asExpr<T1>::T_expr::T_numtype> >                     \
        (asExpr<TinyVector<T2,N> >::getExpr(d1),                          \
         asExpr<T1>::getExpr(d2.unwrap()));                               \
}                                                                         \
                                                                          \
template <typename T1, typename T2, int N>                                \
_bz_inline_et                                                             \
_bz_ArrayExprBinaryOp<                                                    \
    _bz_typename asExpr<T1>::T_expr,                                      \
    _bz_typename asExpr<TinyVector<T2,N> >::T_expr,                       \
    applic<_bz_typename asExpr<T1>::T_expr::T_numtype,                    \
    TinyVector<T2,N> > >                                                  \
name(const ETBase<T1>& d1, const TinyVector<T2,N> d2)                     \
{                                                                         \
    return _bz_ArrayExprBinaryOp<                                         \
        _bz_typename asExpr<T1>::T_expr,                                  \
        _bz_typename asExpr<TinyVector<T2,N> >::T_expr,                   \
        applic<_bz_typename asExpr<T1>::T_expr::T_numtype,                \
        TinyVector<T2,N> > >                                              \
        (asExpr<T1>::getExpr(d1.unwrap()),                                \
         asExpr<TinyVector<T2,N> >::getExpr(d2));                         \
}

#define BZ_DECLARE_ARRAY_ET_BINARY_SCALAR(name, applic, sca)              \
                                                                          \
template<typename T>                                                      \
_bz_inline_et                                                             \
_bz_ArrayExprBinaryOp<                                                    \
    asExpr<sca >::T_expr,                                                 \
    _bz_typename asExpr<T>::T_expr,                                       \
    applic<sca,_bz_typename asExpr<T>::T_expr::T_numtype> >               \
name(const sca d1, const ETBase<T>& d2)                                   \
{                                                                         \
    return _bz_ArrayExprBinaryOp<                                         \
        asExpr<sca >::T_expr,                                             \
        _bz_typename asExpr<T>::T_expr,                                   \
        applic<sca,_bz_typename asExpr<T>::T_expr::T_numtype> >           \
        (asExpr<sca >::getExpr(d1),                                       \
         asExpr<T>::getExpr(d2.unwrap()));                                \
}                                                                         \
                                                                          \
template<typename T>                                                      \
_bz_inline_et                                                             \
_bz_ArrayExprBinaryOp<                                                    \
    _bz_typename asExpr<T>::T_expr,                                       \
    asExpr<sca >::T_expr,                                                 \
    applic<_bz_typename asExpr<T>::T_expr::T_numtype,sca > >              \
name(const ETBase<T>& d1, const sca d2)                                   \
{                                                                         \
    return _bz_ArrayExprBinaryOp<                                         \
        _bz_typename asExpr<T>::T_expr,                                   \
        asExpr<sca >::T_expr,                                             \
        applic<_bz_typename asExpr<T>::T_expr::T_numtype,sca > >          \
        (asExpr<T>::getExpr(d1.unwrap()),                                 \
         asExpr<sca >::getExpr(d2));                                      \
}

/*
 * Array expression templates: the macro BZ_DECLARE_ARRAY_ET_TERNARY(X,Y)
 * declares a function or operator which takes three operands.
 * X is the function name (or operator), and Y is the functor object
 * which implements the operation.
 */

#define BZ_DECLARE_ARRAY_ET_TERNARY(name, applic)                         \
                                                                          \
template<typename T1, typename T2, typename T3>                           \
_bz_inline_et                                                             \
_bz_ArrayExpr<_bz_ArrayExprTernaryOp<                                     \
    _bz_typename asExpr<T1>::T_expr,                                      \
    _bz_typename asExpr<T2>::T_expr,                                      \
    _bz_typename asExpr<T3>::T_expr,                                      \
    applic<_bz_typename asExpr<T1>::T_expr::T_numtype,                    \
           _bz_typename asExpr<T2>::T_expr::T_numtype,                    \
           _bz_typename asExpr<T3>::T_expr::T_numtype> > >                \
name(const ETBase<T1>& d1, const ETBase<T2>& d2, const ETBase<T3>& d3)    \
{                                                                         \
    return _bz_ArrayExpr<_bz_ArrayExprTernaryOp<                          \
        _bz_typename asExpr<T1>::T_expr,                                  \
        _bz_typename asExpr<T2>::T_expr,                                  \
        _bz_typename asExpr<T3>::T_expr,                                  \
        applic<_bz_typename asExpr<T1>::T_expr::T_numtype,                \
               _bz_typename asExpr<T2>::T_expr::T_numtype,                \
               _bz_typename asExpr<T3>::T_expr::T_numtype> > >            \
        (asExpr<T1>::getExpr(d1.unwrap()),                                \
         asExpr<T2>::getExpr(d2.unwrap()),                                \
         asExpr<T3>::getExpr(d3.unwrap()));                               \
}

#endif /* BZ_HAVE_TEMPLATES_AS_TEMPLATE_ARGUMENTS */

/*
 * User-defined expression template routines
 */

#define BZ_DECLARE_FUNCTION(name)                                        \
BZ_DEFINE_UNARY_FUNC(name ## _impl,name)                                 \
BZ_DECLARE_ARRAY_ET_UNARY(name,name ## _impl)

#define BZ_DECLARE_FUNCTION_RET(name,return_type)                        \
BZ_DEFINE_UNARY_FUNC_RET(name ## _impl,name,return_type)                 \
BZ_DECLARE_ARRAY_ET_UNARY(name,name ## _impl)

#define BZ_DECLARE_FUNCTION2(name)                                       \
BZ_DEFINE_BINARY_FUNC(name ## _impl,name)                                \
BZ_DECLARE_ARRAY_ET_BINARY(name, name ## _impl)

#define BZ_DECLARE_FUNCTION2_RET(name,return_type)                       \
BZ_DEFINE_BINARY_FUNC_RET(name ## _impl,name,return_type)                \
BZ_DECLARE_ARRAY_ET_BINARY(name, name ## _impl)

#define BZ_DECLARE_FUNCTION2_SCALAR(name, sca)                           \
BZ_DECLARE_ARRAY_ET_BINARY_SCALAR(name, name ## _impl, sca)

#define BZ_DECLARE_FUNCTION3(name)                                       \
BZ_DEFINE_TERNARY_FUNC(name ## _impl,name)                               \
BZ_DECLARE_ARRAY_ET_TERNARY(name, name ## _impl)
    
#define BZ_DECLARE_FUNCTION3_RET(name,return_type)                       \
BZ_DEFINE_TERNARY_FUNC_RET(name ## _impl,name,return_type)               \
BZ_DECLARE_ARRAY_ET_TERNARY(name, name ## _impl)

BZ_NAMESPACE_END

#endif