.. _program_listing_file_src_functional_predicates.h:

Program Listing for File predicates.h
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_functional_predicates.h>` (``src/functional/predicates.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include "functional/defs.h"
   #include "functional/operands.h"
   
   namespace marian {
   namespace functional {
   
   template <typename Function, typename X>
   struct UnaryFunctor {
     X x;
   
     template <class Arg>
     UnaryFunctor(Arg a) : x(a) {}
   
     template <typename T, typename... Args>
     HOST_DEVICE_INLINE T operator()(T arg, Args&&... args) {
       return Function::apply(x(arg, args...));
     }
   
     std::string to_string() const { return Function::n() + "<" + x.to_string() + ">"; }
   };
   
   template <class Function, class X, class Y>
   struct BinaryFunctor {
     X x;
     Y y;
   
     template <class Arg1, class Arg2>
     BinaryFunctor(Arg1 arg1, Arg2 arg2) : x(arg1), y(arg2) {}
   
     template <typename T, typename... Args>
     HOST_DEVICE_INLINE T operator()(T arg, Args&&... args) {
       return Function::apply(x(arg, args...), y(arg, args...));
     }
   
     std::string to_string() const {
       return Function::n() + "<" + x.to_string() + "," + y.to_string() + ">";
     }
   };
   
   #define UNARY(name, name2, func)                                      \
     namespace elem {                                                    \
     struct name {                                                       \
       template <typename ElementType>                                   \
       HOST_DEVICE_INLINE static ElementType apply(const ElementType& x) { return func; } \
       static std::string n() { return #name; }                          \
     };                                                                  \
     }                                                                   \
     template <class X>                                                  \
     using name = UnaryFunctor<elem::name, X>;                           \
     template <typename X>                                               \
     static inline name<IsClass<X>> name2(X x) {                         \
       return name<X>(x);                                                \
     }                                                                   \
     static inline name<Capture> name2(Capture x) { return name<Capture>(x); }
   
   #define BINARY(name, name2, func)                                 \
     namespace elem {                                                \
     struct name {                                                   \
       template <typename ElementType>                               \
       HOST_DEVICE_INLINE static ElementType apply(const ElementType& x,        \
                                                   const ElementType& y)        \
         { return func; }                                            \
       static std::string n() { return #name; }                      \
     };                                                              \
     }                                                               \
     template <class X, class Y>                                     \
     using name = BinaryFunctor<elem::name, X, Y>;                   \
     template <class X, class Y>                                     \
     name<IsClass<X>, IsClass<Y>> name2(const X& x, const Y& y) {    \
       return name<X, Y>(x, y);                                      \
     }                                                               \
     template <class Y>                                              \
     name<Capture, IsClass<Y>> name2(const Capture& x, const Y& y) { \
       return name<Capture, Y>(x, y);                                \
     }                                                               \
     template <class X>                                              \
     name<IsClass<X>, Capture> name2(const X& x, const Capture& y) { \
       return name<X, Capture>(x, y);                                \
     }
   
   template <class Function, class X, class Y, class Z>
   struct TernaryFunctor {
     X x;
     Y y;
     Z z;
   
     template <class Arg1, class Arg2, class Arg3>
     TernaryFunctor(Arg1 arg1, Arg2 arg2, Arg3 arg3) : x(arg1), y(arg2), z(arg3) {}
   
     template <typename T, typename... Args>
     HOST_DEVICE_INLINE T operator()(T arg, Args&&... args) {
       return Function::apply(x(arg, args...), y(arg, args...), z(arg, args...));
     }
   };
   
   #define TERNARY(name, name2, func)                                         \
     namespace elem {                                                         \
     struct name {                                                            \
       template <typename ElementType>                                        \
       HOST_DEVICE_INLINE static ElementType apply(ElementType x,             \
                                                   ElementType y,             \
                                                   ElementType z)             \
       { return func; }                                                       \
     };                                                                       \
     }                                                                        \
     template <class X, class Y, class Z>                                     \
     using name = TernaryFunctor<elem::name, X, Y, Z>;                        \
     template <typename X, typename Y, typename Z>                            \
     name<IsClass<X>, IsClass<Y>, IsClass<Z>> name2(X x, Y y, Z z) {          \
       return name<X, Y, Z>(x, y, z);                                         \
     }                                                                        \
     template <typename X, typename Z>                                        \
     name<IsClass<X>, Capture, IsClass<Z>> name2(X x, Capture y, Z z) {       \
       return name<X, Capture, Z>(x, y, z);                                   \
     }                                                                        \
     template <typename Y, typename Z>                                        \
     name<Capture, IsClass<Y>, IsClass<Z>> name2(Capture x, Y y, Z z) {       \
       return name<Capture, Y, Z>(x, y, z);                                   \
     }                                                                        \
     template <typename X>                                                    \
     name<IsClass<X>, Capture, Capture> name2(X x, Capture y, Capture z) {    \
       return name<X, Capture, Capture>(x, y, z);                             \
     }                                                                        \
     template <typename Y>                                                    \
     name<Capture, IsClass<Y>, Capture> name2(Capture x, Y y, Capture z) {    \
       return name<Capture, Y, Capture>(x, y, z);                             \
     }                                                                        \
     template <typename Z>                                                    \
     name<Capture, Capture, IsClass<Z>> name2(Capture x, Capture y, Z z) {    \
       return name<Capture, Capture, Z>(x, y, z);                             \
     }
   
   template <class X, class Y>
   struct Assign {
     X x;
     Y y;
   
     template <class Arg1, class Arg2>
     Assign(Arg1 arg1, Arg2 arg2) : x(arg1), y(arg2) {}
   
     template <typename T, typename... Args>
     HOST_DEVICE_INLINE T operator()(T&& arg, Args&&... args) {
       return x(arg, args...) = y(arg, args...);
     }
   
     std::string to_string() const {
       return "Assign<" + x.to_string() + "," + y.to_string() + ">";
     }
   };
   
   template <int N>
   struct Assignee {
     Var<N> var;
   
     Assignee() {}
     Assignee(Var<N> v) : var(v) {}
   
     template <typename T, typename... Args>
     HOST_DEVICE_INLINE T& operator()(T&& arg, Args&&... args) {
       return var(arg, args...);
     }
   
     template <class X>
     Assign<Var<N>, IsClass<X>> operator=(X x) {
       return Assign<Var<N>, X>(var, x);
     }
   
     Assign<Var<N>, Capture> operator=(Capture x) {
       return Assign<Var<N>, Capture>(var, x);
     }
   
     template <class X>
     auto operator+=(X x) -> decltype(*this = *this + x) {
       return *this = *this + x;
     }
   
     template <class X>
     auto operator-=(X x) -> decltype(*this = *this - x) {
       return *this = *this - x;
     }
   
     template <class X>
     auto operator*=(X x) -> decltype(*this = *this * x) {
       return *this = *this * x;
     }
   
     template <class X>
     auto operator/=(X x) -> decltype(*this = *this / x) {
       return *this = *this / x;
     }
   
     std::string to_string() const { return var.to_string(); }
   };
   
   /******************************************************************************/
   }  // namespace functional
   }  // namespace marian