Core/functors/StlFunctors.h

0001 // This file is part of Eigen, a lightweight C++ template library
0002 // for linear algebra.
0003 //
0004 // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
0005 //
0006 // This Source Code Form is subject to the terms of the Mozilla
0007 // Public License v. 2.0. If a copy of the MPL was not distributed
0008 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
0009
0010 #ifndef EIGEN_STL_FUNCTORS_H
0011 #define EIGEN_STL_FUNCTORS_H
0012
0013 namespace Eigen {
0014
0015 // Portable replacements for certain functors.
0016 namespace numext {
0017
0018 template<typename T = void>
0019 struct equal_to {
0020   typedef bool result_type;
0021   EIGEN_DEVICE_FUNC bool operator()(const T& lhs, const T& rhs) const {
0022     return lhs == rhs;
0023   }
0024 };
0025
0026 template<typename T = void>
0027 struct not_equal_to {
0028   typedef bool result_type;
0029   EIGEN_DEVICE_FUNC bool operator()(const T& lhs, const T& rhs) const {
0030     return lhs != rhs;
0031   }
0032 };
0033
0034 }
0035
0036
0037 namespace internal {
0038
0039 // default functor traits for STL functors:
0040
0041 template<typename T>
0042 struct functor_traits<std::multiplies<T> >
0043 { enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
0044
0045 template<typename T>
0046 struct functor_traits<std::divides<T> >
0047 { enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
0048
0049 template<typename T>
0050 struct functor_traits<std::plus<T> >
0051 { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
0052
0053 template<typename T>
0054 struct functor_traits<std::minus<T> >
0055 { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
0056
0057 template<typename T>
0058 struct functor_traits<std::negate<T> >
0059 { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
0060
0061 template<typename T>
0062 struct functor_traits<std::logical_or<T> >
0063 { enum { Cost = 1, PacketAccess = false }; };
0064
0065 template<typename T>
0066 struct functor_traits<std::logical_and<T> >
0067 { enum { Cost = 1, PacketAccess = false }; };
0068
0069 template<typename T>
0070 struct functor_traits<std::logical_not<T> >
0071 { enum { Cost = 1, PacketAccess = false }; };
0072
0073 template<typename T>
0074 struct functor_traits<std::greater<T> >
0075 { enum { Cost = 1, PacketAccess = false }; };
0076
0077 template<typename T>
0078 struct functor_traits<std::less<T> >
0079 { enum { Cost = 1, PacketAccess = false }; };
0080
0081 template<typename T>
0082 struct functor_traits<std::greater_equal<T> >
0083 { enum { Cost = 1, PacketAccess = false }; };
0084
0085 template<typename T>
0086 struct functor_traits<std::less_equal<T> >
0087 { enum { Cost = 1, PacketAccess = false }; };
0088
0089 template<typename T>
0090 struct functor_traits<std::equal_to<T> >
0091 { enum { Cost = 1, PacketAccess = false }; };
0092
0093 template<typename T>
0094 struct functor_traits<numext::equal_to<T> >
0095   : functor_traits<std::equal_to<T> > {};
0096
0097 template<typename T>
0098 struct functor_traits<std::not_equal_to<T> >
0099 { enum { Cost = 1, PacketAccess = false }; };
0100
0101 template<typename T>
0102 struct functor_traits<numext::not_equal_to<T> >
0103   : functor_traits<std::not_equal_to<T> > {};
0104
0105 #if (EIGEN_COMP_CXXVER < 11)
0106 // std::binder* are deprecated since c++11 and will be removed in c++17
0107 template<typename T>
0108 struct functor_traits<std::binder2nd<T> >
0109 { enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
0110
0111 template<typename T>
0112 struct functor_traits<std::binder1st<T> >
0113 { enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
0114 #endif
0115
0116 #if (EIGEN_COMP_CXXVER < 17)
0117 // std::unary_negate is deprecated since c++17 and will be removed in c++20
0118 template<typename T>
0119 struct functor_traits<std::unary_negate<T> >
0120 { enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
0121
0122 // std::binary_negate is deprecated since c++17 and will be removed in c++20
0123 template<typename T>
0124 struct functor_traits<std::binary_negate<T> >
0125 { enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
0126 #endif
0127
0128 #ifdef EIGEN_STDEXT_SUPPORT
0129
0130 template<typename T0,typename T1>
0131 struct functor_traits<std::project1st<T0,T1> >
0132 { enum { Cost = 0, PacketAccess = false }; };
0133
0134 template<typename T0,typename T1>
0135 struct functor_traits<std::project2nd<T0,T1> >
0136 { enum { Cost = 0, PacketAccess = false }; };
0137
0138 template<typename T0,typename T1>
0139 struct functor_traits<std::select2nd<std::pair<T0,T1> > >
0140 { enum { Cost = 0, PacketAccess = false }; };
0141
0142 template<typename T0,typename T1>
0143 struct functor_traits<std::select1st<std::pair<T0,T1> > >
0144 { enum { Cost = 0, PacketAccess = false }; };
0145
0146 template<typename T0,typename T1>
0147 struct functor_traits<std::unary_compose<T0,T1> >
0148 { enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; };
0149
0150 template<typename T0,typename T1,typename T2>
0151 struct functor_traits<std::binary_compose<T0,T1,T2> >
0152 { enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess = false }; };
0153
0154 #endif // EIGEN_STDEXT_SUPPORT
0155
0156 // allow to add new functors and specializations of functor_traits from outside Eigen.
0157 // this macro is really needed because functor_traits must be specialized after it is declared but before it is used...
0158 #ifdef EIGEN_FUNCTORS_PLUGIN
0159 #include EIGEN_FUNCTORS_PLUGIN
0160 #endif
0161
0162 } // end namespace internal
0163
0164 } // end namespace Eigen
0165
0166 #endif // EIGEN_STL_FUNCTORS_H