diff options
Diffstat (limited to 'boost/compute/functional/logical.hpp')
-rw-r--r-- | boost/compute/functional/logical.hpp | 208 |
1 files changed, 208 insertions, 0 deletions
diff --git a/boost/compute/functional/logical.hpp b/boost/compute/functional/logical.hpp new file mode 100644 index 0000000000..2e2c7518b5 --- /dev/null +++ b/boost/compute/functional/logical.hpp @@ -0,0 +1,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 |