functional.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2014 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 <cusp/detail/config.h>
 
#include <cusp/complex.h>
 
#include <thrust/functional.h>
 
namespace cusp
{
 
namespace detail
{
template <typename> struct base_functor;
template <typename> struct combine_tuple_base_functor;
}
template <typename T>
struct plus_value : public detail::base_functor< ::cuda::std::plus<T> >
{
    _CCCL_HOST_DEVICE
    plus_value(const T value = T(0)) : detail::base_functor< ::cuda::std::plus<T> >(value) {}
};
 
template <typename T>
struct divide_value : public detail::base_functor< ::cuda::std::divides<T> >
{
    _CCCL_HOST_DEVICE
    divide_value(const T value = T(0)) : detail::base_functor< ::cuda::std::divides<T> >(value) {}
};
 
template <typename T>
struct modulus_value : public detail::base_functor< ::cuda::std::modulus<T> >
{
    _CCCL_HOST_DEVICE
    modulus_value(const T value = T(0)) : detail::base_functor< ::cuda::std::modulus<T> >(value) {}
};
 
template <typename T>
struct multiplies_value : public detail::base_functor< ::cuda::std::multiplies<T> >
{
    _CCCL_HOST_DEVICE
    multiplies_value(const T value) : detail::base_functor< ::cuda::std::multiplies<T> >(value) {}
};
 
template <typename T>
struct greater_value : public detail::base_functor< ::cuda::std::greater<T> >
{
    _CCCL_HOST_DEVICE
    greater_value(const T value) : detail::base_functor< ::cuda::std::greater<T> >(value) {}
};
 
template <typename T>
struct greater_equal_value : public detail::base_functor< ::cuda::std::greater_equal<T> >
{
    _CCCL_HOST_DEVICE
    greater_equal_value(const T value) : detail::base_functor< ::cuda::std::greater_equal<T> >(value) {}
};
 
template <typename T>
struct less_value : public detail::base_functor< ::cuda::std::less<T> >
{
    _CCCL_HOST_DEVICE
    less_value(const T value) : detail::base_functor< ::cuda::std::less<T> >(value) {}
};
 
template <typename T>
struct less_equal_value : public detail::base_functor< ::cuda::std::less_equal<T> >
{
    _CCCL_HOST_DEVICE
    less_equal_value(const T value) : detail::base_functor< ::cuda::std::less_equal<T> >(value) {}
};
 
template<typename T>
struct constant_functor
{
    private:
      T val;
 
    public:
    _CCCL_HOST_DEVICE
    constant_functor(const T val = 0) : val(val) {}
 
    _CCCL_HOST_DEVICE
    T operator()(const T& x) const {
        return val;
    }
};
 
template <typename T>
struct square_functor
{
    _CCCL_HOST_DEVICE
    T operator()(const T& x) const {
        return x * x;
    }
};
 
template <typename T>
struct sqrt_functor
{
    _CCCL_HOST_DEVICE
    T operator()(const T& x) const {
        using thrust::sqrt;
        using std::sqrt;
 
        return sqrt(x);
    }
};
 
template <typename T>
struct reciprocal_functor
{
    _CCCL_HOST_DEVICE
    T operator()(const T& v) const {
        return T(1.0) / v;
    }
};
 
template<typename T>
struct abs_functor
{
    _CCCL_HOST_DEVICE
    typename cusp::norm_type<T>::type
    operator()(const T& t) const {
        return cusp::abs(t);
    }
};
 
template<typename T>
struct abs_squared_functor
{
    _CCCL_HOST_DEVICE
    typename cusp::norm_type<T>::type
    operator()(const T& t) const {
        return cusp::square_functor<typename cusp::norm_type<T>::type>()(cusp::abs(t));
    }
};
 
template<typename T>
struct conj_functor
{
    _CCCL_HOST_DEVICE
    T operator()(const T& t) const {
        return cusp::conj(t);
    }
};
 
template<typename T>
struct norm_functor
{
    _CCCL_HOST_DEVICE
    typename cusp::norm_type<T>::type
    operator()(const T& t) const {
        return cusp::norm(t);
    }
};
 
template <typename T>
struct sum_pair_functor : public detail::combine_tuple_base_functor< ::cuda::std::plus<T> > {};
 
template <typename T>
struct divide_pair_functor : public detail::combine_tuple_base_functor< ::cuda::std::divides<T> > {};
 
template <typename T>
struct equal_pair_functor : public detail::combine_tuple_base_functor< ::cuda::std::equal_to<T> > {};
 
template <typename T>
struct not_equal_pair_functor : public detail::combine_tuple_base_functor< ::cuda::std::not_equal_to<T> > {};
 
} // end namespace cusp
 
#include <cusp/detail/functional.inl>