1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
//---------------------------------------------------------------------------//
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_FUNCTIONAL_LOGICAL_HPP
#define BOOST_COMPUTE_FUNCTIONAL_LOGICAL_HPP
namespace boost {
namespace compute {
namespace detail {
template<class Predicate, class Expr>
class invoked_unary_negate_function
{
public:
typedef int result_type;
invoked_unary_negate_function(const Predicate &pred,
const Expr &expr)
: m_pred(pred),
m_expr(expr)
{
}
Predicate pred() const
{
return m_pred;
}
Expr expr() const
{
return m_expr;
}
private:
Predicate m_pred;
Expr m_expr;
};
template<class Predicate, class Expr1, class Expr2>
class invoked_binary_negate_function
{
public:
typedef int result_type;
invoked_binary_negate_function(const Predicate &pred,
const Expr1 &expr1,
const Expr2 &expr2)
: m_pred(pred),
m_expr1(expr1),
m_expr2(expr2)
{
}
Predicate pred() const
{
return m_pred;
}
Expr1 expr1() const
{
return m_expr1;
}
Expr2 expr2() const
{
return m_expr2;
}
private:
Predicate m_pred;
Expr1 m_expr1;
Expr2 m_expr2;
};
} // end detail namespace
/// \internal_
template<class Arg, class Result>
struct unary_function
{
typedef Arg argument_type;
typedef Result result_type;
};
/// \internal_
template<class Arg1, class Arg2, class Result>
struct binary_function
{
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
/// \internal_
template<class Arg1, class Arg2, class Arg3, class Result>
struct ternary_function
{
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Arg3 third_argument_type;
typedef Result result_type;
};
/// The unary_negate function adaptor negates a unary function.
///
/// \see not1()
template<class Predicate>
class unary_negate : public unary_function<void, int>
{
public:
explicit unary_negate(Predicate pred)
: m_pred(pred)
{
}
/// \internal_
template<class Arg>
detail::invoked_unary_negate_function<Predicate, Arg>
operator()(const Arg &arg) const
{
return detail::invoked_unary_negate_function<
Predicate,
Arg
>(m_pred, arg);
}
private:
Predicate m_pred;
};
/// The binnary_negate function adaptor negates a binary function.
///
/// \see not2()
template<class Predicate>
class binary_negate : public binary_function<void, void, int>
{
public:
explicit binary_negate(Predicate pred)
: m_pred(pred)
{
}
/// \internal_
template<class Arg1, class Arg2>
detail::invoked_binary_negate_function<Predicate, Arg1, Arg2>
operator()(const Arg1 &arg1, const Arg2 &arg2) const
{
return detail::invoked_binary_negate_function<
Predicate,
Arg1,
Arg2
>(m_pred, arg1, arg2);
}
private:
Predicate m_pred;
};
/// Returns a unary_negate adaptor around \p predicate.
///
/// \param predicate the unary function to wrap
///
/// \return a unary_negate wrapper around \p predicate
template<class Predicate>
inline unary_negate<Predicate> not1(const Predicate &predicate)
{
return unary_negate<Predicate>(predicate);
}
/// Returns a binary_negate adaptor around \p predicate.
///
/// \param predicate the binary function to wrap
///
/// \return a binary_negate wrapper around \p predicate
template<class Predicate>
inline binary_negate<Predicate> not2(const Predicate &predicate)
{
return binary_negate<Predicate>(predicate);
}
/// The logical_not function negates its argument and returns it.
///
/// \see not1(), not2()
template<class T>
struct logical_not : public unary_function<T, int>
{
/// \internal_
template<class Expr>
detail::invoked_function<int, boost::tuple<Expr> >
operator()(const Expr &expr) const
{
return detail::invoked_function<int, boost::tuple<Expr> >(
"!", std::string(), boost::make_tuple(expr)
);
}
};
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_FUNCTIONAL_LOGICAL_HPP
|
