1 | // This file is part of Eigen, a lightweight C++ template library |
---|
2 | // for linear algebra. |
---|
3 | // |
---|
4 | // Copyright (C) 2008-2010 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_FUNCTORS_H |
---|
11 | #define EIGEN_FUNCTORS_H |
---|
12 | |
---|
13 | namespace Eigen { |
---|
14 | |
---|
15 | namespace internal { |
---|
16 | |
---|
17 | // associative functors: |
---|
18 | |
---|
19 | /** \internal |
---|
20 | * \brief Template functor to compute the sum of two scalars |
---|
21 | * |
---|
22 | * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, MatrixBase::sum() |
---|
23 | */ |
---|
24 | template<typename Scalar> struct scalar_sum_op { |
---|
25 | EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op) |
---|
26 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; } |
---|
27 | template<typename Packet> |
---|
28 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
29 | { return internal::padd(a,b); } |
---|
30 | template<typename Packet> |
---|
31 | EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const |
---|
32 | { return internal::predux(a); } |
---|
33 | }; |
---|
34 | template<typename Scalar> |
---|
35 | struct functor_traits<scalar_sum_op<Scalar> > { |
---|
36 | enum { |
---|
37 | Cost = NumTraits<Scalar>::AddCost, |
---|
38 | PacketAccess = packet_traits<Scalar>::HasAdd |
---|
39 | }; |
---|
40 | }; |
---|
41 | |
---|
42 | /** \internal |
---|
43 | * \brief Template functor to compute the product of two scalars |
---|
44 | * |
---|
45 | * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux() |
---|
46 | */ |
---|
47 | template<typename LhsScalar,typename RhsScalar> struct scalar_product_op { |
---|
48 | enum { |
---|
49 | // TODO vectorize mixed product |
---|
50 | Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul |
---|
51 | }; |
---|
52 | typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type; |
---|
53 | EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op) |
---|
54 | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; } |
---|
55 | template<typename Packet> |
---|
56 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
57 | { return internal::pmul(a,b); } |
---|
58 | template<typename Packet> |
---|
59 | EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const |
---|
60 | { return internal::predux_mul(a); } |
---|
61 | }; |
---|
62 | template<typename LhsScalar,typename RhsScalar> |
---|
63 | struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > { |
---|
64 | enum { |
---|
65 | Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate! |
---|
66 | PacketAccess = scalar_product_op<LhsScalar,RhsScalar>::Vectorizable |
---|
67 | }; |
---|
68 | }; |
---|
69 | |
---|
70 | /** \internal |
---|
71 | * \brief Template functor to compute the conjugate product of two scalars |
---|
72 | * |
---|
73 | * This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y) |
---|
74 | */ |
---|
75 | template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op { |
---|
76 | |
---|
77 | enum { |
---|
78 | Conj = NumTraits<LhsScalar>::IsComplex |
---|
79 | }; |
---|
80 | |
---|
81 | typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type; |
---|
82 | |
---|
83 | EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op) |
---|
84 | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const |
---|
85 | { return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); } |
---|
86 | |
---|
87 | template<typename Packet> |
---|
88 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
89 | { return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); } |
---|
90 | }; |
---|
91 | template<typename LhsScalar,typename RhsScalar> |
---|
92 | struct functor_traits<scalar_conj_product_op<LhsScalar,RhsScalar> > { |
---|
93 | enum { |
---|
94 | Cost = NumTraits<LhsScalar>::MulCost, |
---|
95 | PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul |
---|
96 | }; |
---|
97 | }; |
---|
98 | |
---|
99 | /** \internal |
---|
100 | * \brief Template functor to compute the min of two scalars |
---|
101 | * |
---|
102 | * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff() |
---|
103 | */ |
---|
104 | template<typename Scalar> struct scalar_min_op { |
---|
105 | EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op) |
---|
106 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::min; return (min)(a, b); } |
---|
107 | template<typename Packet> |
---|
108 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
109 | { return internal::pmin(a,b); } |
---|
110 | template<typename Packet> |
---|
111 | EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const |
---|
112 | { return internal::predux_min(a); } |
---|
113 | }; |
---|
114 | template<typename Scalar> |
---|
115 | struct functor_traits<scalar_min_op<Scalar> > { |
---|
116 | enum { |
---|
117 | Cost = NumTraits<Scalar>::AddCost, |
---|
118 | PacketAccess = packet_traits<Scalar>::HasMin |
---|
119 | }; |
---|
120 | }; |
---|
121 | |
---|
122 | /** \internal |
---|
123 | * \brief Template functor to compute the max of two scalars |
---|
124 | * |
---|
125 | * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff() |
---|
126 | */ |
---|
127 | template<typename Scalar> struct scalar_max_op { |
---|
128 | EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op) |
---|
129 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::max; return (max)(a, b); } |
---|
130 | template<typename Packet> |
---|
131 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
132 | { return internal::pmax(a,b); } |
---|
133 | template<typename Packet> |
---|
134 | EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const |
---|
135 | { return internal::predux_max(a); } |
---|
136 | }; |
---|
137 | template<typename Scalar> |
---|
138 | struct functor_traits<scalar_max_op<Scalar> > { |
---|
139 | enum { |
---|
140 | Cost = NumTraits<Scalar>::AddCost, |
---|
141 | PacketAccess = packet_traits<Scalar>::HasMax |
---|
142 | }; |
---|
143 | }; |
---|
144 | |
---|
145 | /** \internal |
---|
146 | * \brief Template functor to compute the hypot of two scalars |
---|
147 | * |
---|
148 | * \sa MatrixBase::stableNorm(), class Redux |
---|
149 | */ |
---|
150 | template<typename Scalar> struct scalar_hypot_op { |
---|
151 | EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op) |
---|
152 | // typedef typename NumTraits<Scalar>::Real result_type; |
---|
153 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& _x, const Scalar& _y) const |
---|
154 | { |
---|
155 | using std::max; |
---|
156 | using std::min; |
---|
157 | Scalar p = (max)(_x, _y); |
---|
158 | Scalar q = (min)(_x, _y); |
---|
159 | Scalar qp = q/p; |
---|
160 | return p * sqrt(Scalar(1) + qp*qp); |
---|
161 | } |
---|
162 | }; |
---|
163 | template<typename Scalar> |
---|
164 | struct functor_traits<scalar_hypot_op<Scalar> > { |
---|
165 | enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 }; |
---|
166 | }; |
---|
167 | |
---|
168 | /** \internal |
---|
169 | * \brief Template functor to compute the pow of two scalars |
---|
170 | */ |
---|
171 | template<typename Scalar, typename OtherScalar> struct scalar_binary_pow_op { |
---|
172 | EIGEN_EMPTY_STRUCT_CTOR(scalar_binary_pow_op) |
---|
173 | inline Scalar operator() (const Scalar& a, const OtherScalar& b) const { return internal::pow(a, b); } |
---|
174 | }; |
---|
175 | template<typename Scalar, typename OtherScalar> |
---|
176 | struct functor_traits<scalar_binary_pow_op<Scalar,OtherScalar> > { |
---|
177 | enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; |
---|
178 | }; |
---|
179 | |
---|
180 | // other binary functors: |
---|
181 | |
---|
182 | /** \internal |
---|
183 | * \brief Template functor to compute the difference of two scalars |
---|
184 | * |
---|
185 | * \sa class CwiseBinaryOp, MatrixBase::operator- |
---|
186 | */ |
---|
187 | template<typename Scalar> struct scalar_difference_op { |
---|
188 | EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op) |
---|
189 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; } |
---|
190 | template<typename Packet> |
---|
191 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
192 | { return internal::psub(a,b); } |
---|
193 | }; |
---|
194 | template<typename Scalar> |
---|
195 | struct functor_traits<scalar_difference_op<Scalar> > { |
---|
196 | enum { |
---|
197 | Cost = NumTraits<Scalar>::AddCost, |
---|
198 | PacketAccess = packet_traits<Scalar>::HasSub |
---|
199 | }; |
---|
200 | }; |
---|
201 | |
---|
202 | /** \internal |
---|
203 | * \brief Template functor to compute the quotient of two scalars |
---|
204 | * |
---|
205 | * \sa class CwiseBinaryOp, Cwise::operator/() |
---|
206 | */ |
---|
207 | template<typename Scalar> struct scalar_quotient_op { |
---|
208 | EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op) |
---|
209 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a / b; } |
---|
210 | template<typename Packet> |
---|
211 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const |
---|
212 | { return internal::pdiv(a,b); } |
---|
213 | }; |
---|
214 | template<typename Scalar> |
---|
215 | struct functor_traits<scalar_quotient_op<Scalar> > { |
---|
216 | enum { |
---|
217 | Cost = 2 * NumTraits<Scalar>::MulCost, |
---|
218 | PacketAccess = packet_traits<Scalar>::HasDiv |
---|
219 | }; |
---|
220 | }; |
---|
221 | |
---|
222 | /** \internal |
---|
223 | * \brief Template functor to compute the and of two booleans |
---|
224 | * |
---|
225 | * \sa class CwiseBinaryOp, ArrayBase::operator&& |
---|
226 | */ |
---|
227 | struct scalar_boolean_and_op { |
---|
228 | EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op) |
---|
229 | EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; } |
---|
230 | }; |
---|
231 | template<> struct functor_traits<scalar_boolean_and_op> { |
---|
232 | enum { |
---|
233 | Cost = NumTraits<bool>::AddCost, |
---|
234 | PacketAccess = false |
---|
235 | }; |
---|
236 | }; |
---|
237 | |
---|
238 | /** \internal |
---|
239 | * \brief Template functor to compute the or of two booleans |
---|
240 | * |
---|
241 | * \sa class CwiseBinaryOp, ArrayBase::operator|| |
---|
242 | */ |
---|
243 | struct scalar_boolean_or_op { |
---|
244 | EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op) |
---|
245 | EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; } |
---|
246 | }; |
---|
247 | template<> struct functor_traits<scalar_boolean_or_op> { |
---|
248 | enum { |
---|
249 | Cost = NumTraits<bool>::AddCost, |
---|
250 | PacketAccess = false |
---|
251 | }; |
---|
252 | }; |
---|
253 | |
---|
254 | // unary functors: |
---|
255 | |
---|
256 | /** \internal |
---|
257 | * \brief Template functor to compute the opposite of a scalar |
---|
258 | * |
---|
259 | * \sa class CwiseUnaryOp, MatrixBase::operator- |
---|
260 | */ |
---|
261 | template<typename Scalar> struct scalar_opposite_op { |
---|
262 | EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op) |
---|
263 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; } |
---|
264 | template<typename Packet> |
---|
265 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const |
---|
266 | { return internal::pnegate(a); } |
---|
267 | }; |
---|
268 | template<typename Scalar> |
---|
269 | struct functor_traits<scalar_opposite_op<Scalar> > |
---|
270 | { enum { |
---|
271 | Cost = NumTraits<Scalar>::AddCost, |
---|
272 | PacketAccess = packet_traits<Scalar>::HasNegate }; |
---|
273 | }; |
---|
274 | |
---|
275 | /** \internal |
---|
276 | * \brief Template functor to compute the absolute value of a scalar |
---|
277 | * |
---|
278 | * \sa class CwiseUnaryOp, Cwise::abs |
---|
279 | */ |
---|
280 | template<typename Scalar> struct scalar_abs_op { |
---|
281 | EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op) |
---|
282 | typedef typename NumTraits<Scalar>::Real result_type; |
---|
283 | EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs(a); } |
---|
284 | template<typename Packet> |
---|
285 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const |
---|
286 | { return internal::pabs(a); } |
---|
287 | }; |
---|
288 | template<typename Scalar> |
---|
289 | struct functor_traits<scalar_abs_op<Scalar> > |
---|
290 | { |
---|
291 | enum { |
---|
292 | Cost = NumTraits<Scalar>::AddCost, |
---|
293 | PacketAccess = packet_traits<Scalar>::HasAbs |
---|
294 | }; |
---|
295 | }; |
---|
296 | |
---|
297 | /** \internal |
---|
298 | * \brief Template functor to compute the squared absolute value of a scalar |
---|
299 | * |
---|
300 | * \sa class CwiseUnaryOp, Cwise::abs2 |
---|
301 | */ |
---|
302 | template<typename Scalar> struct scalar_abs2_op { |
---|
303 | EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op) |
---|
304 | typedef typename NumTraits<Scalar>::Real result_type; |
---|
305 | EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs2(a); } |
---|
306 | template<typename Packet> |
---|
307 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const |
---|
308 | { return internal::pmul(a,a); } |
---|
309 | }; |
---|
310 | template<typename Scalar> |
---|
311 | struct functor_traits<scalar_abs2_op<Scalar> > |
---|
312 | { enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; }; |
---|
313 | |
---|
314 | /** \internal |
---|
315 | * \brief Template functor to compute the conjugate of a complex value |
---|
316 | * |
---|
317 | * \sa class CwiseUnaryOp, MatrixBase::conjugate() |
---|
318 | */ |
---|
319 | template<typename Scalar> struct scalar_conjugate_op { |
---|
320 | EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op) |
---|
321 | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return internal::conj(a); } |
---|
322 | template<typename Packet> |
---|
323 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); } |
---|
324 | }; |
---|
325 | template<typename Scalar> |
---|
326 | struct functor_traits<scalar_conjugate_op<Scalar> > |
---|
327 | { |
---|
328 | enum { |
---|
329 | Cost = NumTraits<Scalar>::IsComplex ? NumTraits<Scalar>::AddCost : 0, |
---|
330 | PacketAccess = packet_traits<Scalar>::HasConj |
---|
331 | }; |
---|
332 | }; |
---|
333 | |
---|
334 | /** \internal |
---|
335 | * \brief Template functor to cast a scalar to another type |
---|
336 | * |
---|
337 | * \sa class CwiseUnaryOp, MatrixBase::cast() |
---|
338 | */ |
---|
339 | template<typename Scalar, typename NewType> |
---|
340 | struct scalar_cast_op { |
---|
341 | EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op) |
---|
342 | typedef NewType result_type; |
---|
343 | EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); } |
---|
344 | }; |
---|
345 | template<typename Scalar, typename NewType> |
---|
346 | struct functor_traits<scalar_cast_op<Scalar,NewType> > |
---|
347 | { enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; }; |
---|
348 | |
---|
349 | /** \internal |
---|
350 | * \brief Template functor to extract the real part of a complex |
---|
351 | * |
---|
352 | * \sa class CwiseUnaryOp, MatrixBase::real() |
---|
353 | */ |
---|
354 | template<typename Scalar> |
---|
355 | struct scalar_real_op { |
---|
356 | EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op) |
---|
357 | typedef typename NumTraits<Scalar>::Real result_type; |
---|
358 | EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::real(a); } |
---|
359 | }; |
---|
360 | template<typename Scalar> |
---|
361 | struct functor_traits<scalar_real_op<Scalar> > |
---|
362 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
363 | |
---|
364 | /** \internal |
---|
365 | * \brief Template functor to extract the imaginary part of a complex |
---|
366 | * |
---|
367 | * \sa class CwiseUnaryOp, MatrixBase::imag() |
---|
368 | */ |
---|
369 | template<typename Scalar> |
---|
370 | struct scalar_imag_op { |
---|
371 | EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op) |
---|
372 | typedef typename NumTraits<Scalar>::Real result_type; |
---|
373 | EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::imag(a); } |
---|
374 | }; |
---|
375 | template<typename Scalar> |
---|
376 | struct functor_traits<scalar_imag_op<Scalar> > |
---|
377 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
378 | |
---|
379 | /** \internal |
---|
380 | * \brief Template functor to extract the real part of a complex as a reference |
---|
381 | * |
---|
382 | * \sa class CwiseUnaryOp, MatrixBase::real() |
---|
383 | */ |
---|
384 | template<typename Scalar> |
---|
385 | struct scalar_real_ref_op { |
---|
386 | EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op) |
---|
387 | typedef typename NumTraits<Scalar>::Real result_type; |
---|
388 | EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::real_ref(*const_cast<Scalar*>(&a)); } |
---|
389 | }; |
---|
390 | template<typename Scalar> |
---|
391 | struct functor_traits<scalar_real_ref_op<Scalar> > |
---|
392 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
393 | |
---|
394 | /** \internal |
---|
395 | * \brief Template functor to extract the imaginary part of a complex as a reference |
---|
396 | * |
---|
397 | * \sa class CwiseUnaryOp, MatrixBase::imag() |
---|
398 | */ |
---|
399 | template<typename Scalar> |
---|
400 | struct scalar_imag_ref_op { |
---|
401 | EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op) |
---|
402 | typedef typename NumTraits<Scalar>::Real result_type; |
---|
403 | EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::imag_ref(*const_cast<Scalar*>(&a)); } |
---|
404 | }; |
---|
405 | template<typename Scalar> |
---|
406 | struct functor_traits<scalar_imag_ref_op<Scalar> > |
---|
407 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
408 | |
---|
409 | /** \internal |
---|
410 | * |
---|
411 | * \brief Template functor to compute the exponential of a scalar |
---|
412 | * |
---|
413 | * \sa class CwiseUnaryOp, Cwise::exp() |
---|
414 | */ |
---|
415 | template<typename Scalar> struct scalar_exp_op { |
---|
416 | EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op) |
---|
417 | inline const Scalar operator() (const Scalar& a) const { return internal::exp(a); } |
---|
418 | typedef typename packet_traits<Scalar>::type Packet; |
---|
419 | inline Packet packetOp(const Packet& a) const { return internal::pexp(a); } |
---|
420 | }; |
---|
421 | template<typename Scalar> |
---|
422 | struct functor_traits<scalar_exp_op<Scalar> > |
---|
423 | { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; }; |
---|
424 | |
---|
425 | /** \internal |
---|
426 | * |
---|
427 | * \brief Template functor to compute the logarithm of a scalar |
---|
428 | * |
---|
429 | * \sa class CwiseUnaryOp, Cwise::log() |
---|
430 | */ |
---|
431 | template<typename Scalar> struct scalar_log_op { |
---|
432 | EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op) |
---|
433 | inline const Scalar operator() (const Scalar& a) const { return internal::log(a); } |
---|
434 | typedef typename packet_traits<Scalar>::type Packet; |
---|
435 | inline Packet packetOp(const Packet& a) const { return internal::plog(a); } |
---|
436 | }; |
---|
437 | template<typename Scalar> |
---|
438 | struct functor_traits<scalar_log_op<Scalar> > |
---|
439 | { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; }; |
---|
440 | |
---|
441 | /** \internal |
---|
442 | * \brief Template functor to multiply a scalar by a fixed other one |
---|
443 | * |
---|
444 | * \sa class CwiseUnaryOp, MatrixBase::operator*, MatrixBase::operator/ |
---|
445 | */ |
---|
446 | /* NOTE why doing the pset1() in packetOp *is* an optimization ? |
---|
447 | * indeed it seems better to declare m_other as a Packet and do the pset1() once |
---|
448 | * in the constructor. However, in practice: |
---|
449 | * - GCC does not like m_other as a Packet and generate a load every time it needs it |
---|
450 | * - on the other hand GCC is able to moves the pset1() outside the loop :) |
---|
451 | * - simpler code ;) |
---|
452 | * (ICC and gcc 4.4 seems to perform well in both cases, the issue is visible with y = a*x + b*y) |
---|
453 | */ |
---|
454 | template<typename Scalar> |
---|
455 | struct scalar_multiple_op { |
---|
456 | typedef typename packet_traits<Scalar>::type Packet; |
---|
457 | // FIXME default copy constructors seems bugged with std::complex<> |
---|
458 | EIGEN_STRONG_INLINE scalar_multiple_op(const scalar_multiple_op& other) : m_other(other.m_other) { } |
---|
459 | EIGEN_STRONG_INLINE scalar_multiple_op(const Scalar& other) : m_other(other) { } |
---|
460 | EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a * m_other; } |
---|
461 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const |
---|
462 | { return internal::pmul(a, pset1<Packet>(m_other)); } |
---|
463 | typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other; |
---|
464 | }; |
---|
465 | template<typename Scalar> |
---|
466 | struct functor_traits<scalar_multiple_op<Scalar> > |
---|
467 | { enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; |
---|
468 | |
---|
469 | template<typename Scalar1, typename Scalar2> |
---|
470 | struct scalar_multiple2_op { |
---|
471 | typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type; |
---|
472 | EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { } |
---|
473 | EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { } |
---|
474 | EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; } |
---|
475 | typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other; |
---|
476 | }; |
---|
477 | template<typename Scalar1,typename Scalar2> |
---|
478 | struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> > |
---|
479 | { enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess = false }; }; |
---|
480 | |
---|
481 | /** \internal |
---|
482 | * \brief Template functor to divide a scalar by a fixed other one |
---|
483 | * |
---|
484 | * This functor is used to implement the quotient of a matrix by |
---|
485 | * a scalar where the scalar type is not necessarily a floating point type. |
---|
486 | * |
---|
487 | * \sa class CwiseUnaryOp, MatrixBase::operator/ |
---|
488 | */ |
---|
489 | template<typename Scalar> |
---|
490 | struct scalar_quotient1_op { |
---|
491 | typedef typename packet_traits<Scalar>::type Packet; |
---|
492 | // FIXME default copy constructors seems bugged with std::complex<> |
---|
493 | EIGEN_STRONG_INLINE scalar_quotient1_op(const scalar_quotient1_op& other) : m_other(other.m_other) { } |
---|
494 | EIGEN_STRONG_INLINE scalar_quotient1_op(const Scalar& other) : m_other(other) {} |
---|
495 | EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; } |
---|
496 | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const |
---|
497 | { return internal::pdiv(a, pset1<Packet>(m_other)); } |
---|
498 | typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other; |
---|
499 | }; |
---|
500 | template<typename Scalar> |
---|
501 | struct functor_traits<scalar_quotient1_op<Scalar> > |
---|
502 | { enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; }; |
---|
503 | |
---|
504 | // nullary functors |
---|
505 | |
---|
506 | template<typename Scalar> |
---|
507 | struct scalar_constant_op { |
---|
508 | typedef typename packet_traits<Scalar>::type Packet; |
---|
509 | EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { } |
---|
510 | EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { } |
---|
511 | template<typename Index> |
---|
512 | EIGEN_STRONG_INLINE const Scalar operator() (Index, Index = 0) const { return m_other; } |
---|
513 | template<typename Index> |
---|
514 | EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return internal::pset1<Packet>(m_other); } |
---|
515 | const Scalar m_other; |
---|
516 | }; |
---|
517 | template<typename Scalar> |
---|
518 | struct functor_traits<scalar_constant_op<Scalar> > |
---|
519 | // FIXME replace this packet test by a safe one |
---|
520 | { enum { Cost = 1, PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; }; |
---|
521 | |
---|
522 | template<typename Scalar> struct scalar_identity_op { |
---|
523 | EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op) |
---|
524 | template<typename Index> |
---|
525 | EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { return row==col ? Scalar(1) : Scalar(0); } |
---|
526 | }; |
---|
527 | template<typename Scalar> |
---|
528 | struct functor_traits<scalar_identity_op<Scalar> > |
---|
529 | { enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; }; |
---|
530 | |
---|
531 | template <typename Scalar, bool RandomAccess> struct linspaced_op_impl; |
---|
532 | |
---|
533 | // linear access for packet ops: |
---|
534 | // 1) initialization |
---|
535 | // base = [low, ..., low] + ([step, ..., step] * [-size, ..., 0]) |
---|
536 | // 2) each step (where size is 1 for coeff access or PacketSize for packet access) |
---|
537 | // base += [size*step, ..., size*step] |
---|
538 | // |
---|
539 | // TODO: Perhaps it's better to initialize lazily (so not in the constructor but in packetOp) |
---|
540 | // in order to avoid the padd() in operator() ? |
---|
541 | template <typename Scalar> |
---|
542 | struct linspaced_op_impl<Scalar,false> |
---|
543 | { |
---|
544 | typedef typename packet_traits<Scalar>::type Packet; |
---|
545 | |
---|
546 | linspaced_op_impl(Scalar low, Scalar step) : |
---|
547 | m_low(low), m_step(step), |
---|
548 | m_packetStep(pset1<Packet>(packet_traits<Scalar>::size*step)), |
---|
549 | m_base(padd(pset1<Packet>(low), pmul(pset1<Packet>(step),plset<Scalar>(-packet_traits<Scalar>::size)))) {} |
---|
550 | |
---|
551 | template<typename Index> |
---|
552 | EIGEN_STRONG_INLINE const Scalar operator() (Index i) const |
---|
553 | { |
---|
554 | m_base = padd(m_base, pset1<Packet>(m_step)); |
---|
555 | return m_low+i*m_step; |
---|
556 | } |
---|
557 | |
---|
558 | template<typename Index> |
---|
559 | EIGEN_STRONG_INLINE const Packet packetOp(Index) const { return m_base = padd(m_base,m_packetStep); } |
---|
560 | |
---|
561 | const Scalar m_low; |
---|
562 | const Scalar m_step; |
---|
563 | const Packet m_packetStep; |
---|
564 | mutable Packet m_base; |
---|
565 | }; |
---|
566 | |
---|
567 | // random access for packet ops: |
---|
568 | // 1) each step |
---|
569 | // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) ) |
---|
570 | template <typename Scalar> |
---|
571 | struct linspaced_op_impl<Scalar,true> |
---|
572 | { |
---|
573 | typedef typename packet_traits<Scalar>::type Packet; |
---|
574 | |
---|
575 | linspaced_op_impl(Scalar low, Scalar step) : |
---|
576 | m_low(low), m_step(step), |
---|
577 | m_lowPacket(pset1<Packet>(m_low)), m_stepPacket(pset1<Packet>(m_step)), m_interPacket(plset<Scalar>(0)) {} |
---|
578 | |
---|
579 | template<typename Index> |
---|
580 | EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } |
---|
581 | |
---|
582 | template<typename Index> |
---|
583 | EIGEN_STRONG_INLINE const Packet packetOp(Index i) const |
---|
584 | { return internal::padd(m_lowPacket, pmul(m_stepPacket, padd(pset1<Packet>(i),m_interPacket))); } |
---|
585 | |
---|
586 | const Scalar m_low; |
---|
587 | const Scalar m_step; |
---|
588 | const Packet m_lowPacket; |
---|
589 | const Packet m_stepPacket; |
---|
590 | const Packet m_interPacket; |
---|
591 | }; |
---|
592 | |
---|
593 | // ----- Linspace functor ---------------------------------------------------------------- |
---|
594 | |
---|
595 | // Forward declaration (we default to random access which does not really give |
---|
596 | // us a speed gain when using packet access but it allows to use the functor in |
---|
597 | // nested expressions). |
---|
598 | template <typename Scalar, bool RandomAccess = true> struct linspaced_op; |
---|
599 | template <typename Scalar, bool RandomAccess> struct functor_traits< linspaced_op<Scalar,RandomAccess> > |
---|
600 | { enum { Cost = 1, PacketAccess = packet_traits<Scalar>::HasSetLinear, IsRepeatable = true }; }; |
---|
601 | template <typename Scalar, bool RandomAccess> struct linspaced_op |
---|
602 | { |
---|
603 | typedef typename packet_traits<Scalar>::type Packet; |
---|
604 | linspaced_op(Scalar low, Scalar high, int num_steps) : impl((num_steps==1 ? high : low), (num_steps==1 ? Scalar() : (high-low)/(num_steps-1))) {} |
---|
605 | |
---|
606 | template<typename Index> |
---|
607 | EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); } |
---|
608 | |
---|
609 | // We need this function when assigning e.g. a RowVectorXd to a MatrixXd since |
---|
610 | // there row==0 and col is used for the actual iteration. |
---|
611 | template<typename Index> |
---|
612 | EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const |
---|
613 | { |
---|
614 | eigen_assert(col==0 || row==0); |
---|
615 | return impl(col + row); |
---|
616 | } |
---|
617 | |
---|
618 | template<typename Index> |
---|
619 | EIGEN_STRONG_INLINE const Packet packetOp(Index i) const { return impl.packetOp(i); } |
---|
620 | |
---|
621 | // We need this function when assigning e.g. a RowVectorXd to a MatrixXd since |
---|
622 | // there row==0 and col is used for the actual iteration. |
---|
623 | template<typename Index> |
---|
624 | EIGEN_STRONG_INLINE const Packet packetOp(Index row, Index col) const |
---|
625 | { |
---|
626 | eigen_assert(col==0 || row==0); |
---|
627 | return impl.packetOp(col + row); |
---|
628 | } |
---|
629 | |
---|
630 | // This proxy object handles the actual required temporaries, the different |
---|
631 | // implementations (random vs. sequential access) as well as the |
---|
632 | // correct piping to size 2/4 packet operations. |
---|
633 | const linspaced_op_impl<Scalar,RandomAccess> impl; |
---|
634 | }; |
---|
635 | |
---|
636 | // all functors allow linear access, except scalar_identity_op. So we fix here a quick meta |
---|
637 | // to indicate whether a functor allows linear access, just always answering 'yes' except for |
---|
638 | // scalar_identity_op. |
---|
639 | // FIXME move this to functor_traits adding a functor_default |
---|
640 | template<typename Functor> struct functor_has_linear_access { enum { ret = 1 }; }; |
---|
641 | template<typename Scalar> struct functor_has_linear_access<scalar_identity_op<Scalar> > { enum { ret = 0 }; }; |
---|
642 | |
---|
643 | // in CwiseBinaryOp, we require the Lhs and Rhs to have the same scalar type, except for multiplication |
---|
644 | // where we only require them to have the same _real_ scalar type so one may multiply, say, float by complex<float>. |
---|
645 | // FIXME move this to functor_traits adding a functor_default |
---|
646 | template<typename Functor> struct functor_allows_mixing_real_and_complex { enum { ret = 0 }; }; |
---|
647 | template<typename LhsScalar,typename RhsScalar> struct functor_allows_mixing_real_and_complex<scalar_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; }; |
---|
648 | template<typename LhsScalar,typename RhsScalar> struct functor_allows_mixing_real_and_complex<scalar_conj_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; }; |
---|
649 | |
---|
650 | |
---|
651 | /** \internal |
---|
652 | * \brief Template functor to add a scalar to a fixed other one |
---|
653 | * \sa class CwiseUnaryOp, Array::operator+ |
---|
654 | */ |
---|
655 | /* If you wonder why doing the pset1() in packetOp() is an optimization check scalar_multiple_op */ |
---|
656 | template<typename Scalar> |
---|
657 | struct scalar_add_op { |
---|
658 | typedef typename packet_traits<Scalar>::type Packet; |
---|
659 | // FIXME default copy constructors seems bugged with std::complex<> |
---|
660 | inline scalar_add_op(const scalar_add_op& other) : m_other(other.m_other) { } |
---|
661 | inline scalar_add_op(const Scalar& other) : m_other(other) { } |
---|
662 | inline Scalar operator() (const Scalar& a) const { return a + m_other; } |
---|
663 | inline const Packet packetOp(const Packet& a) const |
---|
664 | { return internal::padd(a, pset1<Packet>(m_other)); } |
---|
665 | const Scalar m_other; |
---|
666 | }; |
---|
667 | template<typename Scalar> |
---|
668 | struct functor_traits<scalar_add_op<Scalar> > |
---|
669 | { enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; }; |
---|
670 | |
---|
671 | /** \internal |
---|
672 | * \brief Template functor to compute the square root of a scalar |
---|
673 | * \sa class CwiseUnaryOp, Cwise::sqrt() |
---|
674 | */ |
---|
675 | template<typename Scalar> struct scalar_sqrt_op { |
---|
676 | EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op) |
---|
677 | inline const Scalar operator() (const Scalar& a) const { return internal::sqrt(a); } |
---|
678 | typedef typename packet_traits<Scalar>::type Packet; |
---|
679 | inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); } |
---|
680 | }; |
---|
681 | template<typename Scalar> |
---|
682 | struct functor_traits<scalar_sqrt_op<Scalar> > |
---|
683 | { enum { |
---|
684 | Cost = 5 * NumTraits<Scalar>::MulCost, |
---|
685 | PacketAccess = packet_traits<Scalar>::HasSqrt |
---|
686 | }; |
---|
687 | }; |
---|
688 | |
---|
689 | /** \internal |
---|
690 | * \brief Template functor to compute the cosine of a scalar |
---|
691 | * \sa class CwiseUnaryOp, ArrayBase::cos() |
---|
692 | */ |
---|
693 | template<typename Scalar> struct scalar_cos_op { |
---|
694 | EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op) |
---|
695 | inline Scalar operator() (const Scalar& a) const { return internal::cos(a); } |
---|
696 | typedef typename packet_traits<Scalar>::type Packet; |
---|
697 | inline Packet packetOp(const Packet& a) const { return internal::pcos(a); } |
---|
698 | }; |
---|
699 | template<typename Scalar> |
---|
700 | struct functor_traits<scalar_cos_op<Scalar> > |
---|
701 | { |
---|
702 | enum { |
---|
703 | Cost = 5 * NumTraits<Scalar>::MulCost, |
---|
704 | PacketAccess = packet_traits<Scalar>::HasCos |
---|
705 | }; |
---|
706 | }; |
---|
707 | |
---|
708 | /** \internal |
---|
709 | * \brief Template functor to compute the sine of a scalar |
---|
710 | * \sa class CwiseUnaryOp, ArrayBase::sin() |
---|
711 | */ |
---|
712 | template<typename Scalar> struct scalar_sin_op { |
---|
713 | EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op) |
---|
714 | inline const Scalar operator() (const Scalar& a) const { return internal::sin(a); } |
---|
715 | typedef typename packet_traits<Scalar>::type Packet; |
---|
716 | inline Packet packetOp(const Packet& a) const { return internal::psin(a); } |
---|
717 | }; |
---|
718 | template<typename Scalar> |
---|
719 | struct functor_traits<scalar_sin_op<Scalar> > |
---|
720 | { |
---|
721 | enum { |
---|
722 | Cost = 5 * NumTraits<Scalar>::MulCost, |
---|
723 | PacketAccess = packet_traits<Scalar>::HasSin |
---|
724 | }; |
---|
725 | }; |
---|
726 | |
---|
727 | |
---|
728 | /** \internal |
---|
729 | * \brief Template functor to compute the tan of a scalar |
---|
730 | * \sa class CwiseUnaryOp, ArrayBase::tan() |
---|
731 | */ |
---|
732 | template<typename Scalar> struct scalar_tan_op { |
---|
733 | EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op) |
---|
734 | inline const Scalar operator() (const Scalar& a) const { return internal::tan(a); } |
---|
735 | typedef typename packet_traits<Scalar>::type Packet; |
---|
736 | inline Packet packetOp(const Packet& a) const { return internal::ptan(a); } |
---|
737 | }; |
---|
738 | template<typename Scalar> |
---|
739 | struct functor_traits<scalar_tan_op<Scalar> > |
---|
740 | { |
---|
741 | enum { |
---|
742 | Cost = 5 * NumTraits<Scalar>::MulCost, |
---|
743 | PacketAccess = packet_traits<Scalar>::HasTan |
---|
744 | }; |
---|
745 | }; |
---|
746 | |
---|
747 | /** \internal |
---|
748 | * \brief Template functor to compute the arc cosine of a scalar |
---|
749 | * \sa class CwiseUnaryOp, ArrayBase::acos() |
---|
750 | */ |
---|
751 | template<typename Scalar> struct scalar_acos_op { |
---|
752 | EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op) |
---|
753 | inline const Scalar operator() (const Scalar& a) const { return internal::acos(a); } |
---|
754 | typedef typename packet_traits<Scalar>::type Packet; |
---|
755 | inline Packet packetOp(const Packet& a) const { return internal::pacos(a); } |
---|
756 | }; |
---|
757 | template<typename Scalar> |
---|
758 | struct functor_traits<scalar_acos_op<Scalar> > |
---|
759 | { |
---|
760 | enum { |
---|
761 | Cost = 5 * NumTraits<Scalar>::MulCost, |
---|
762 | PacketAccess = packet_traits<Scalar>::HasACos |
---|
763 | }; |
---|
764 | }; |
---|
765 | |
---|
766 | /** \internal |
---|
767 | * \brief Template functor to compute the arc sine of a scalar |
---|
768 | * \sa class CwiseUnaryOp, ArrayBase::asin() |
---|
769 | */ |
---|
770 | template<typename Scalar> struct scalar_asin_op { |
---|
771 | EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op) |
---|
772 | inline const Scalar operator() (const Scalar& a) const { return internal::asin(a); } |
---|
773 | typedef typename packet_traits<Scalar>::type Packet; |
---|
774 | inline Packet packetOp(const Packet& a) const { return internal::pasin(a); } |
---|
775 | }; |
---|
776 | template<typename Scalar> |
---|
777 | struct functor_traits<scalar_asin_op<Scalar> > |
---|
778 | { |
---|
779 | enum { |
---|
780 | Cost = 5 * NumTraits<Scalar>::MulCost, |
---|
781 | PacketAccess = packet_traits<Scalar>::HasASin |
---|
782 | }; |
---|
783 | }; |
---|
784 | |
---|
785 | /** \internal |
---|
786 | * \brief Template functor to raise a scalar to a power |
---|
787 | * \sa class CwiseUnaryOp, Cwise::pow |
---|
788 | */ |
---|
789 | template<typename Scalar> |
---|
790 | struct scalar_pow_op { |
---|
791 | // FIXME default copy constructors seems bugged with std::complex<> |
---|
792 | inline scalar_pow_op(const scalar_pow_op& other) : m_exponent(other.m_exponent) { } |
---|
793 | inline scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {} |
---|
794 | inline Scalar operator() (const Scalar& a) const { return internal::pow(a, m_exponent); } |
---|
795 | const Scalar m_exponent; |
---|
796 | }; |
---|
797 | template<typename Scalar> |
---|
798 | struct functor_traits<scalar_pow_op<Scalar> > |
---|
799 | { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; }; |
---|
800 | |
---|
801 | /** \internal |
---|
802 | * \brief Template functor to compute the quotient between a scalar and array entries. |
---|
803 | * \sa class CwiseUnaryOp, Cwise::inverse() |
---|
804 | */ |
---|
805 | template<typename Scalar> |
---|
806 | struct scalar_inverse_mult_op { |
---|
807 | scalar_inverse_mult_op(const Scalar& other) : m_other(other) {} |
---|
808 | inline Scalar operator() (const Scalar& a) const { return m_other / a; } |
---|
809 | template<typename Packet> |
---|
810 | inline const Packet packetOp(const Packet& a) const |
---|
811 | { return internal::pdiv(pset1<Packet>(m_other),a); } |
---|
812 | Scalar m_other; |
---|
813 | }; |
---|
814 | |
---|
815 | /** \internal |
---|
816 | * \brief Template functor to compute the inverse of a scalar |
---|
817 | * \sa class CwiseUnaryOp, Cwise::inverse() |
---|
818 | */ |
---|
819 | template<typename Scalar> |
---|
820 | struct scalar_inverse_op { |
---|
821 | EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op) |
---|
822 | inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; } |
---|
823 | template<typename Packet> |
---|
824 | inline const Packet packetOp(const Packet& a) const |
---|
825 | { return internal::pdiv(pset1<Packet>(Scalar(1)),a); } |
---|
826 | }; |
---|
827 | template<typename Scalar> |
---|
828 | struct functor_traits<scalar_inverse_op<Scalar> > |
---|
829 | { enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; }; |
---|
830 | |
---|
831 | /** \internal |
---|
832 | * \brief Template functor to compute the square of a scalar |
---|
833 | * \sa class CwiseUnaryOp, Cwise::square() |
---|
834 | */ |
---|
835 | template<typename Scalar> |
---|
836 | struct scalar_square_op { |
---|
837 | EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op) |
---|
838 | inline Scalar operator() (const Scalar& a) const { return a*a; } |
---|
839 | template<typename Packet> |
---|
840 | inline const Packet packetOp(const Packet& a) const |
---|
841 | { return internal::pmul(a,a); } |
---|
842 | }; |
---|
843 | template<typename Scalar> |
---|
844 | struct functor_traits<scalar_square_op<Scalar> > |
---|
845 | { enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; |
---|
846 | |
---|
847 | /** \internal |
---|
848 | * \brief Template functor to compute the cube of a scalar |
---|
849 | * \sa class CwiseUnaryOp, Cwise::cube() |
---|
850 | */ |
---|
851 | template<typename Scalar> |
---|
852 | struct scalar_cube_op { |
---|
853 | EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op) |
---|
854 | inline Scalar operator() (const Scalar& a) const { return a*a*a; } |
---|
855 | template<typename Packet> |
---|
856 | inline const Packet packetOp(const Packet& a) const |
---|
857 | { return internal::pmul(a,pmul(a,a)); } |
---|
858 | }; |
---|
859 | template<typename Scalar> |
---|
860 | struct functor_traits<scalar_cube_op<Scalar> > |
---|
861 | { enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; |
---|
862 | |
---|
863 | // default functor traits for STL functors: |
---|
864 | |
---|
865 | template<typename T> |
---|
866 | struct functor_traits<std::multiplies<T> > |
---|
867 | { enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; }; |
---|
868 | |
---|
869 | template<typename T> |
---|
870 | struct functor_traits<std::divides<T> > |
---|
871 | { enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; }; |
---|
872 | |
---|
873 | template<typename T> |
---|
874 | struct functor_traits<std::plus<T> > |
---|
875 | { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; }; |
---|
876 | |
---|
877 | template<typename T> |
---|
878 | struct functor_traits<std::minus<T> > |
---|
879 | { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; }; |
---|
880 | |
---|
881 | template<typename T> |
---|
882 | struct functor_traits<std::negate<T> > |
---|
883 | { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; }; |
---|
884 | |
---|
885 | template<typename T> |
---|
886 | struct functor_traits<std::logical_or<T> > |
---|
887 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
888 | |
---|
889 | template<typename T> |
---|
890 | struct functor_traits<std::logical_and<T> > |
---|
891 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
892 | |
---|
893 | template<typename T> |
---|
894 | struct functor_traits<std::logical_not<T> > |
---|
895 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
896 | |
---|
897 | template<typename T> |
---|
898 | struct functor_traits<std::greater<T> > |
---|
899 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
900 | |
---|
901 | template<typename T> |
---|
902 | struct functor_traits<std::less<T> > |
---|
903 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
904 | |
---|
905 | template<typename T> |
---|
906 | struct functor_traits<std::greater_equal<T> > |
---|
907 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
908 | |
---|
909 | template<typename T> |
---|
910 | struct functor_traits<std::less_equal<T> > |
---|
911 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
912 | |
---|
913 | template<typename T> |
---|
914 | struct functor_traits<std::equal_to<T> > |
---|
915 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
916 | |
---|
917 | template<typename T> |
---|
918 | struct functor_traits<std::not_equal_to<T> > |
---|
919 | { enum { Cost = 1, PacketAccess = false }; }; |
---|
920 | |
---|
921 | template<typename T> |
---|
922 | struct functor_traits<std::binder2nd<T> > |
---|
923 | { enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; }; |
---|
924 | |
---|
925 | template<typename T> |
---|
926 | struct functor_traits<std::binder1st<T> > |
---|
927 | { enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; }; |
---|
928 | |
---|
929 | template<typename T> |
---|
930 | struct functor_traits<std::unary_negate<T> > |
---|
931 | { enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; }; |
---|
932 | |
---|
933 | template<typename T> |
---|
934 | struct functor_traits<std::binary_negate<T> > |
---|
935 | { enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; }; |
---|
936 | |
---|
937 | #ifdef EIGEN_STDEXT_SUPPORT |
---|
938 | |
---|
939 | template<typename T0,typename T1> |
---|
940 | struct functor_traits<std::project1st<T0,T1> > |
---|
941 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
942 | |
---|
943 | template<typename T0,typename T1> |
---|
944 | struct functor_traits<std::project2nd<T0,T1> > |
---|
945 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
946 | |
---|
947 | template<typename T0,typename T1> |
---|
948 | struct functor_traits<std::select2nd<std::pair<T0,T1> > > |
---|
949 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
950 | |
---|
951 | template<typename T0,typename T1> |
---|
952 | struct functor_traits<std::select1st<std::pair<T0,T1> > > |
---|
953 | { enum { Cost = 0, PacketAccess = false }; }; |
---|
954 | |
---|
955 | template<typename T0,typename T1> |
---|
956 | struct functor_traits<std::unary_compose<T0,T1> > |
---|
957 | { enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; }; |
---|
958 | |
---|
959 | template<typename T0,typename T1,typename T2> |
---|
960 | struct functor_traits<std::binary_compose<T0,T1,T2> > |
---|
961 | { enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess = false }; }; |
---|
962 | |
---|
963 | #endif // EIGEN_STDEXT_SUPPORT |
---|
964 | |
---|
965 | // allow to add new functors and specializations of functor_traits from outside Eigen. |
---|
966 | // this macro is really needed because functor_traits must be specialized after it is declared but before it is used... |
---|
967 | #ifdef EIGEN_FUNCTORS_PLUGIN |
---|
968 | #include EIGEN_FUNCTORS_PLUGIN |
---|
969 | #endif |
---|
970 | |
---|
971 | } // end namespace internal |
---|
972 | |
---|
973 | } // end namespace Eigen |
---|
974 | |
---|
975 | #endif // EIGEN_FUNCTORS_H |
---|