functional.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2018 NVIDIA Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */


#pragma once

#include <thrust/detail/config.h>
#include <functional>
#include <thrust/detail/functional/placeholder.h>

THRUST_NAMESPACE_BEGIN

template<typename Operation> struct unary_traits;

template<typename Operation> struct binary_traits;

template<typename Argument,
         typename Result>
struct unary_function
{
  typedef Argument argument_type;

  typedef Result   result_type;
}; // end unary_function

template<typename Argument1,
         typename Argument2,
         typename Result>
struct binary_function
{
  typedef Argument1 first_argument_type;

  typedef Argument2 second_argument_type;

  typedef Result    result_type;
}; // end binary_function

#define THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(func, impl)                   \
  template <>                                                                  \
  struct func<void>                                                            \
  {                                                                            \
    using is_transparent = void;                                               \
    __thrust_exec_check_disable__                                              \
    template <typename T>                                                      \
    __host__ __device__                                                        \
    constexpr auto operator()(T&& x) const                                     \
      noexcept(noexcept(impl)) THRUST_TRAILING_RETURN(decltype(impl))          \
    {                                                                          \
      return impl;                                                             \
    }                                                                          \
  }

#define THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(func, impl)                  \
  template <>                                                                  \
  struct func<void>                                                            \
  {                                                                            \
    using is_transparent = void;                                               \
    __thrust_exec_check_disable__                                              \
    template <typename T1, typename T2>                                        \
    __host__ __device__                                                        \
    constexpr auto operator()(T1&& t1, T2&& t2) const                          \
      noexcept(noexcept(impl)) THRUST_TRAILING_RETURN(decltype(impl))          \
    {                                                                          \
      return impl;                                                             \
    }                                                                          \
  }

#define THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(func, op)                 \
  THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(                                   \
    func, THRUST_FWD(t1) op THRUST_FWD(t2))


template<typename T = void>
struct plus
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs + rhs;
  }
}; // end plus

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(plus, +);

template<typename T = void>
struct minus
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs - rhs;
  }
}; // end minus

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(minus, -);

template<typename T = void>
struct multiplies
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs * rhs;
  }
}; // end multiplies

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(multiplies, *);

template<typename T = void>
struct divides
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs / rhs;
  }
}; // end divides

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(divides, /);

template<typename T = void>
struct modulus
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs % rhs;
  }
}; // end modulus

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(modulus, %);

template<typename T = void>
struct negate
{
  typedef T argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &x) const
  {
    return -x;
  }
}; // end negate

THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(negate, -THRUST_FWD(x));

template<typename T = void>
struct square
{
  typedef T argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &x) const
  {
    return x*x;
  }
}; // end square

THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(square, x*x);

template<typename T = void>
struct equal_to
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs == rhs;
  }
}; // end equal_to

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(equal_to, ==);

template<typename T = void>
struct not_equal_to
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs != rhs;
  }
}; // end not_equal_to

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(not_equal_to, !=);

template<typename T = void>
struct greater
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs > rhs;
  }
}; // end greater

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(greater, >);

template<typename T = void>
struct less
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs < rhs;
  }
}; // end less

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(less, <);

template<typename T = void>
struct greater_equal
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs >= rhs;
  }
}; // end greater_equal

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(greater_equal, >=);

template<typename T = void>
struct less_equal
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs <= rhs;
  }
}; // end less_equal

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(less_equal, <=);

template<typename T = void>
struct logical_and
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs && rhs;
  }
}; // end logical_and

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(logical_and, &&);

template<typename T = void>
struct logical_or
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &lhs, const T &rhs) const
  {
    return lhs || rhs;
  }
}; // end logical_or

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(logical_or, ||);

template<typename T = void>
struct logical_not
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef bool result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr bool operator()(const T &x) const
  {
    return !x;
  }
}; // end logical_not

THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(logical_not, !THRUST_FWD(x));

template<typename T = void>
struct bit_and
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs & rhs;
  }
}; // end bit_and

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(bit_and, &);

template<typename T = void>
struct bit_or
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs | rhs;
  }
}; // end bit_or

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(bit_or, |);

template<typename T = void>
struct bit_xor
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs ^ rhs;
  }
}; // end bit_xor

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(bit_xor, ^);

template<typename T = void>
struct identity
{
  typedef T argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr const T &operator()(const T &x) const
  {
    return x;
  }
}; // end identity

THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(identity, THRUST_FWD(x));

template<typename T = void>
struct maximum
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs < rhs ? rhs : lhs;
  }
}; // end maximum

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(maximum,
                                          t1 < t2 ? THRUST_FWD(t2)
                                                  : THRUST_FWD(t1));

template<typename T = void>
struct minimum
{
  typedef T first_argument_type;

  typedef T second_argument_type;

  typedef T result_type;

  __thrust_exec_check_disable__
  __host__ __device__
  constexpr T operator()(const T &lhs, const T &rhs) const
  {
    return lhs < rhs ? lhs : rhs;
  }
}; // end minimum

THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(minimum,
                                          t1 < t2 ? THRUST_FWD(t1)
                                                  : THRUST_FWD(t2));

template<typename T1 = void, typename T2 = void>
struct project1st
{
  typedef T1 first_argument_type;

  typedef T2 second_argument_type;

  typedef T1 result_type;

  __host__ __device__
  constexpr const T1 &operator()(const T1 &lhs, const T2 & /*rhs*/) const
  {
    return lhs;
  }
}; // end project1st

template <>
struct project1st<void, void>
{
  using is_transparent = void;
  __thrust_exec_check_disable__
  template <typename T1, typename T2>
  __host__ __device__
  constexpr auto operator()(T1&& t1, T2&&) const
    noexcept(noexcept(THRUST_FWD(t1)))
    THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)))
  {
    return THRUST_FWD(t1);
  }
};

template<typename T1 = void, typename T2 = void>
struct project2nd
{
  typedef T1 first_argument_type;

  typedef T2 second_argument_type;

  typedef T2 result_type;

  __host__ __device__
  constexpr const T2 &operator()(const T1 &/*lhs*/, const T2 &rhs) const
  {
    return rhs;
  }
}; // end project2nd

template <>
struct project2nd<void, void>
{
  using is_transparent = void;
  __thrust_exec_check_disable__
  template <typename T1, typename T2>
  __host__ __device__
  constexpr auto operator()(T1&&, T2&& t2) const
  noexcept(noexcept(THRUST_FWD(t2)))
  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t2)))
  {
    return THRUST_FWD(t2);
  }
};

// odds and ends

template<typename Predicate>
struct unary_negate
    : public thrust::unary_function<typename Predicate::argument_type, bool>
{
  __host__ __device__
  explicit unary_negate(Predicate p) : pred(p){}

  __thrust_exec_check_disable__
  __host__ __device__
  bool operator()(const typename Predicate::argument_type& x) { return !pred(x); }

  Predicate pred;
}; // end unary_negate

template<typename Predicate>
  __host__ __device__
  unary_negate<Predicate> not1(const Predicate &pred);

template<typename Predicate>
struct binary_negate
    : public thrust::binary_function<typename Predicate::first_argument_type,
                                     typename Predicate::second_argument_type,
                                     bool>
{
  __host__ __device__
  explicit binary_negate(Predicate p) : pred(p){}

  __thrust_exec_check_disable__
  __host__ __device__
  bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y)
  {
      return !pred(x,y);
  }

  Predicate pred;
}; // end binary_negate

template<typename BinaryPredicate>
  __host__ __device__
  binary_negate<BinaryPredicate> not2(const BinaryPredicate &pred);

namespace placeholders
{


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<0>::type _1;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<1>::type _2;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<2>::type _3;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<3>::type _4;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<4>::type _5;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<5>::type _6;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<6>::type _7;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<7>::type _8;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<8>::type _9;


THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<9>::type _10;


} // end placeholders


#undef THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION
#undef THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION
#undef THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP

THRUST_NAMESPACE_END

#include <thrust/detail/functional.inl>
#include <thrust/detail/functional/operators.h>