Branch data Line data Source code
1 : : // This file is part of Eigen, a lightweight C++ template library
2 : : // for linear algebra.
3 : : //
4 : : // Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
5 : : //
6 : : // This Source Code Form is subject to the terms of the Mozilla
7 : : // Public License v. 2.0. If a copy of the MPL was not distributed
8 : : // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 : :
10 : : #ifndef EIGEN_NULLARY_FUNCTORS_H
11 : : #define EIGEN_NULLARY_FUNCTORS_H
12 : :
13 : : namespace Eigen {
14 : :
15 : : namespace internal {
16 : :
17 : : template<typename Scalar>
18 : : struct scalar_constant_op {
19 : 153750 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { }
20 : 47195 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { }
21 : 34819 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() () const { return m_other; }
22 : : template<typename PacketType>
23 : 60625 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packetOp() const { return internal::pset1<PacketType>(m_other); }
24 : : const Scalar m_other;
25 : : };
26 : : template<typename Scalar>
27 : : struct functor_traits<scalar_constant_op<Scalar> >
28 : : { enum { Cost = 0 /* as the constant value should be loaded in register only once for the whole expression */,
29 : : PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; };
30 : :
31 : : template<typename Scalar> struct scalar_identity_op {
32 : 3356 : EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
33 : : template<typename IndexType>
34 : 3978 : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType row, IndexType col) const { return row==col ? Scalar(1) : Scalar(0); }
35 : : };
36 : : template<typename Scalar>
37 : : struct functor_traits<scalar_identity_op<Scalar> >
38 : : { enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; };
39 : :
40 : : template <typename Scalar, bool IsInteger> struct linspaced_op_impl;
41 : :
42 : : template <typename Scalar>
43 : : struct linspaced_op_impl<Scalar,/*IsInteger*/false>
44 : : {
45 : : typedef typename NumTraits<Scalar>::Real RealScalar;
46 : :
47 : : EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
48 : : m_low(low), m_high(high), m_size1(num_steps==1 ? 1 : num_steps-1), m_step(num_steps==1 ? Scalar() : Scalar((high-low)/RealScalar(num_steps-1))),
49 : : m_flip(numext::abs(high)<numext::abs(low))
50 : : {}
51 : :
52 : : template<typename IndexType>
53 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const {
54 : : if(m_flip)
55 : : return (i==0)? m_low : Scalar(m_high - RealScalar(m_size1-i)*m_step);
56 : : else
57 : : return (i==m_size1)? m_high : Scalar(m_low + RealScalar(i)*m_step);
58 : : }
59 : :
60 : : template<typename Packet, typename IndexType>
61 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const
62 : : {
63 : : // Principle:
64 : : // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) )
65 : : if(m_flip)
66 : : {
67 : : Packet pi = plset<Packet>(Scalar(i-m_size1));
68 : : Packet res = padd(pset1<Packet>(m_high), pmul(pset1<Packet>(m_step), pi));
69 : : if (EIGEN_PREDICT_TRUE(i != 0)) return res;
70 : : Packet mask = pcmp_lt(pset1<Packet>(0), plset<Packet>(0));
71 : : return pselect<Packet>(mask, res, pset1<Packet>(m_low));
72 : : }
73 : : else
74 : : {
75 : : Packet pi = plset<Packet>(Scalar(i));
76 : : Packet res = padd(pset1<Packet>(m_low), pmul(pset1<Packet>(m_step), pi));
77 : : if(EIGEN_PREDICT_TRUE(i != m_size1-unpacket_traits<Packet>::size+1)) return res;
78 : : Packet mask = pcmp_lt(plset<Packet>(0), pset1<Packet>(unpacket_traits<Packet>::size-1));
79 : : return pselect<Packet>(mask, res, pset1<Packet>(m_high));
80 : : }
81 : : }
82 : :
83 : : const Scalar m_low;
84 : : const Scalar m_high;
85 : : const Index m_size1;
86 : : const Scalar m_step;
87 : : const bool m_flip;
88 : : };
89 : :
90 : : template <typename Scalar>
91 : : struct linspaced_op_impl<Scalar,/*IsInteger*/true>
92 : : {
93 : : EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
94 : : m_low(low),
95 : : m_multiplier((high-low)/convert_index<Scalar>(num_steps<=1 ? 1 : num_steps-1)),
96 : : m_divisor(convert_index<Scalar>((high>=low?num_steps:-num_steps)+(high-low))/((numext::abs(high-low)+1)==0?1:(numext::abs(high-low)+1))),
97 : : m_use_divisor(num_steps>1 && (numext::abs(high-low)+1)<num_steps)
98 : : {}
99 : :
100 : : template<typename IndexType>
101 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
102 : : const Scalar operator() (IndexType i) const
103 : : {
104 : : if(m_use_divisor) return m_low + convert_index<Scalar>(i)/m_divisor;
105 : : else return m_low + convert_index<Scalar>(i)*m_multiplier;
106 : : }
107 : :
108 : : const Scalar m_low;
109 : : const Scalar m_multiplier;
110 : : const Scalar m_divisor;
111 : : const bool m_use_divisor;
112 : : };
113 : :
114 : : // ----- Linspace functor ----------------------------------------------------------------
115 : :
116 : : // Forward declaration (we default to random access which does not really give
117 : : // us a speed gain when using packet access but it allows to use the functor in
118 : : // nested expressions).
119 : : template <typename Scalar> struct linspaced_op;
120 : : template <typename Scalar> struct functor_traits< linspaced_op<Scalar> >
121 : : {
122 : : enum
123 : : {
124 : : Cost = 1,
125 : : PacketAccess = (!NumTraits<Scalar>::IsInteger) && packet_traits<Scalar>::HasSetLinear && packet_traits<Scalar>::HasBlend,
126 : : /*&& ((!NumTraits<Scalar>::IsInteger) || packet_traits<Scalar>::HasDiv),*/ // <- vectorization for integer is currently disabled
127 : : IsRepeatable = true
128 : : };
129 : : };
130 : : template <typename Scalar> struct linspaced_op
131 : : {
132 : : EIGEN_DEVICE_FUNC linspaced_op(const Scalar& low, const Scalar& high, Index num_steps)
133 : : : impl((num_steps==1 ? high : low),high,num_steps)
134 : : {}
135 : :
136 : : template<typename IndexType>
137 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const { return impl(i); }
138 : :
139 : : template<typename Packet,typename IndexType>
140 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return impl.template packetOp<Packet>(i); }
141 : :
142 : : // This proxy object handles the actual required temporaries and the different
143 : : // implementations (integer vs. floating point).
144 : : const linspaced_op_impl<Scalar,NumTraits<Scalar>::IsInteger> impl;
145 : : };
146 : :
147 : : // Linear access is automatically determined from the operator() prototypes available for the given functor.
148 : : // If it exposes an operator()(i,j), then we assume the i and j coefficients are required independently
149 : : // and linear access is not possible. In all other cases, linear access is enabled.
150 : : // Users should not have to deal with this structure.
151 : : template<typename Functor> struct functor_has_linear_access { enum { ret = !has_binary_operator<Functor>::value }; };
152 : :
153 : : // For unreliable compilers, let's specialize the has_*ary_operator
154 : : // helpers so that at least built-in nullary functors work fine.
155 : : #if !( (EIGEN_COMP_MSVC>1600) || (EIGEN_GNUC_AT_LEAST(4,8)) || (EIGEN_COMP_ICC>=1600))
156 : : template<typename Scalar,typename IndexType>
157 : : struct has_nullary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 1}; };
158 : : template<typename Scalar,typename IndexType>
159 : : struct has_unary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
160 : : template<typename Scalar,typename IndexType>
161 : : struct has_binary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
162 : :
163 : : template<typename Scalar,typename IndexType>
164 : : struct has_nullary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
165 : : template<typename Scalar,typename IndexType>
166 : : struct has_unary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
167 : : template<typename Scalar,typename IndexType>
168 : : struct has_binary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 1}; };
169 : :
170 : : template<typename Scalar,typename IndexType>
171 : : struct has_nullary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 0}; };
172 : : template<typename Scalar,typename IndexType>
173 : : struct has_unary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 1}; };
174 : : template<typename Scalar,typename IndexType>
175 : : struct has_binary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 0}; };
176 : :
177 : : template<typename Scalar,typename IndexType>
178 : : struct has_nullary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 1}; };
179 : : template<typename Scalar,typename IndexType>
180 : : struct has_unary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
181 : : template<typename Scalar,typename IndexType>
182 : : struct has_binary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
183 : : #endif
184 : :
185 : : } // end namespace internal
186 : :
187 : : } // end namespace Eigen
188 : :
189 : : #endif // EIGEN_NULLARY_FUNCTORS_H
|
