Eigen  3.2.10
 
Loading...
Searching...
No Matches
Functors.h
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
13namespace Eigen {
14
15namespace internal {
16
17// associative functors:
18
24template<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};
34template<typename Scalar>
35struct functor_traits<scalar_sum_op<Scalar> > {
36 enum {
37 Cost = NumTraits<Scalar>::AddCost,
38 PacketAccess = packet_traits<Scalar>::HasAdd
39 };
40};
41
47template<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};
62template<typename LhsScalar,typename RhsScalar>
63struct 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
75template<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};
91template<typename LhsScalar,typename RhsScalar>
92struct 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
104template<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};
114template<typename Scalar>
115struct functor_traits<scalar_min_op<Scalar> > {
116 enum {
117 Cost = NumTraits<Scalar>::AddCost,
118 PacketAccess = packet_traits<Scalar>::HasMin
119 };
120};
121
127template<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};
137template<typename Scalar>
138struct functor_traits<scalar_max_op<Scalar> > {
139 enum {
140 Cost = NumTraits<Scalar>::AddCost,
141 PacketAccess = packet_traits<Scalar>::HasMax
142 };
143};
144
150template<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 using std::sqrt;
158 Scalar p = (max)(_x, _y);
159 Scalar q = (min)(_x, _y);
160 Scalar qp = q/p;
161 return p * sqrt(Scalar(1) + qp*qp);
162 }
163};
164template<typename Scalar>
165struct functor_traits<scalar_hypot_op<Scalar> > {
166 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 };
167};
168
172template<typename Scalar, typename OtherScalar> struct scalar_binary_pow_op {
173 EIGEN_EMPTY_STRUCT_CTOR(scalar_binary_pow_op)
174 inline Scalar operator() (const Scalar& a, const OtherScalar& b) const { return numext::pow(a, b); }
175};
176template<typename Scalar, typename OtherScalar>
177struct functor_traits<scalar_binary_pow_op<Scalar,OtherScalar> > {
178 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
179};
180
181// other binary functors:
182
188template<typename Scalar> struct scalar_difference_op {
189 EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
190 EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; }
191 template<typename Packet>
192 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
193 { return internal::psub(a,b); }
194};
195template<typename Scalar>
196struct functor_traits<scalar_difference_op<Scalar> > {
197 enum {
198 Cost = NumTraits<Scalar>::AddCost,
199 PacketAccess = packet_traits<Scalar>::HasSub
200 };
201};
202
208template<typename LhsScalar,typename RhsScalar> struct scalar_quotient_op {
209 enum {
210 // TODO vectorize mixed product
211 Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv
212 };
213 typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
214 EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
215 EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
216 template<typename Packet>
217 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
218 { return internal::pdiv(a,b); }
219};
220template<typename LhsScalar,typename RhsScalar>
221struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
222 enum {
223 Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost), // rough estimate!
224 PacketAccess = scalar_quotient_op<LhsScalar,RhsScalar>::Vectorizable
225 };
226};
227
228
229
235struct scalar_boolean_and_op {
236 EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op)
237 EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; }
238};
239template<> struct functor_traits<scalar_boolean_and_op> {
240 enum {
241 Cost = NumTraits<bool>::AddCost,
242 PacketAccess = false
243 };
244};
245
251struct scalar_boolean_or_op {
252 EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op)
253 EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; }
254};
255template<> struct functor_traits<scalar_boolean_or_op> {
256 enum {
257 Cost = NumTraits<bool>::AddCost,
258 PacketAccess = false
259 };
260};
261
266template<typename Scalar, ComparisonName cmp> struct scalar_cmp_op;
267
268template<typename Scalar, ComparisonName cmp>
269struct functor_traits<scalar_cmp_op<Scalar, cmp> > {
270 enum {
271 Cost = NumTraits<Scalar>::AddCost,
272 PacketAccess = false
273 };
274};
275
276template<ComparisonName Cmp, typename Scalar>
277struct result_of<scalar_cmp_op<Scalar, Cmp>(Scalar,Scalar)> {
278 typedef bool type;
279};
280
281
282template<typename Scalar> struct scalar_cmp_op<Scalar, cmp_EQ> {
283 EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
284 EIGEN_STRONG_INLINE bool operator()(const Scalar& a, const Scalar& b) const {return a==b;}
285};
286template<typename Scalar> struct scalar_cmp_op<Scalar, cmp_LT> {
287 EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
288 EIGEN_STRONG_INLINE bool operator()(const Scalar& a, const Scalar& b) const {return a<b;}
289};
290template<typename Scalar> struct scalar_cmp_op<Scalar, cmp_LE> {
291 EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
292 EIGEN_STRONG_INLINE bool operator()(const Scalar& a, const Scalar& b) const {return a<=b;}
293};
294template<typename Scalar> struct scalar_cmp_op<Scalar, cmp_UNORD> {
295 EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
296 EIGEN_STRONG_INLINE bool operator()(const Scalar& a, const Scalar& b) const {return !(a<=b || b<=a);}
297};
298template<typename Scalar> struct scalar_cmp_op<Scalar, cmp_NEQ> {
299 EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
300 EIGEN_STRONG_INLINE bool operator()(const Scalar& a, const Scalar& b) const {return a!=b;}
301};
302
303// unary functors:
304
310template<typename Scalar> struct scalar_opposite_op {
311 EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op)
312 EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; }
313 template<typename Packet>
314 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
315 { return internal::pnegate(a); }
316};
317template<typename Scalar>
318struct functor_traits<scalar_opposite_op<Scalar> >
319{ enum {
320 Cost = NumTraits<Scalar>::AddCost,
321 PacketAccess = packet_traits<Scalar>::HasNegate };
322};
323
329template<typename Scalar> struct scalar_abs_op {
330 EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
331 typedef typename NumTraits<Scalar>::Real result_type;
332 EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { using std::abs; return abs(a); }
333 template<typename Packet>
334 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
335 { return internal::pabs(a); }
336};
337template<typename Scalar>
338struct functor_traits<scalar_abs_op<Scalar> >
339{
340 enum {
341 Cost = NumTraits<Scalar>::AddCost,
342 PacketAccess = packet_traits<Scalar>::HasAbs
343 };
344};
345
351template<typename Scalar> struct scalar_abs2_op {
352 EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
353 typedef typename NumTraits<Scalar>::Real result_type;
354 EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs2(a); }
355 template<typename Packet>
356 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
357 { return internal::pmul(a,a); }
358};
359template<typename Scalar>
360struct functor_traits<scalar_abs2_op<Scalar> >
361{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; };
362
368template<typename Scalar> struct scalar_conjugate_op {
369 EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
370 EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { using numext::conj; return conj(a); }
371 template<typename Packet>
372 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); }
373};
374template<typename Scalar>
375struct functor_traits<scalar_conjugate_op<Scalar> >
376{
377 enum {
378 Cost = NumTraits<Scalar>::IsComplex ? NumTraits<Scalar>::AddCost : 0,
379 PacketAccess = packet_traits<Scalar>::HasConj
380 };
381};
382
388template<typename Scalar, typename NewType>
389struct scalar_cast_op {
390 EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
391 typedef NewType result_type;
392 EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); }
393};
394template<typename Scalar, typename NewType>
395struct functor_traits<scalar_cast_op<Scalar,NewType> >
396{ enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; };
397
403template<typename Scalar>
404struct scalar_real_op {
405 EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
406 typedef typename NumTraits<Scalar>::Real result_type;
407 EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::real(a); }
408};
409template<typename Scalar>
410struct functor_traits<scalar_real_op<Scalar> >
411{ enum { Cost = 0, PacketAccess = false }; };
412
418template<typename Scalar>
419struct scalar_imag_op {
420 EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
421 typedef typename NumTraits<Scalar>::Real result_type;
422 EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::imag(a); }
423};
424template<typename Scalar>
425struct functor_traits<scalar_imag_op<Scalar> >
426{ enum { Cost = 0, PacketAccess = false }; };
427
433template<typename Scalar>
434struct scalar_real_ref_op {
435 EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
436 typedef typename NumTraits<Scalar>::Real result_type;
437 EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::real_ref(*const_cast<Scalar*>(&a)); }
438};
439template<typename Scalar>
440struct functor_traits<scalar_real_ref_op<Scalar> >
441{ enum { Cost = 0, PacketAccess = false }; };
442
448template<typename Scalar>
449struct scalar_imag_ref_op {
450 EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
451 typedef typename NumTraits<Scalar>::Real result_type;
452 EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::imag_ref(*const_cast<Scalar*>(&a)); }
453};
454template<typename Scalar>
455struct functor_traits<scalar_imag_ref_op<Scalar> >
456{ enum { Cost = 0, PacketAccess = false }; };
457
464template<typename Scalar> struct scalar_exp_op {
465 EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
466 inline const Scalar operator() (const Scalar& a) const { using std::exp; return exp(a); }
467 typedef typename packet_traits<Scalar>::type Packet;
468 inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
469};
470template<typename Scalar>
471struct functor_traits<scalar_exp_op<Scalar> >
472{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; };
473
480template<typename Scalar> struct scalar_log_op {
481 EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
482 inline const Scalar operator() (const Scalar& a) const { using std::log; return log(a); }
483 typedef typename packet_traits<Scalar>::type Packet;
484 inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
485};
486template<typename Scalar>
487struct functor_traits<scalar_log_op<Scalar> >
488{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };
489
495/* NOTE why doing the pset1() in packetOp *is* an optimization ?
496 * indeed it seems better to declare m_other as a Packet and do the pset1() once
497 * in the constructor. However, in practice:
498 * - GCC does not like m_other as a Packet and generate a load every time it needs it
499 * - on the other hand GCC is able to moves the pset1() outside the loop :)
500 * - simpler code ;)
501 * (ICC and gcc 4.4 seems to perform well in both cases, the issue is visible with y = a*x + b*y)
502 */
503template<typename Scalar>
504struct scalar_multiple_op {
505 typedef typename packet_traits<Scalar>::type Packet;
506 // FIXME default copy constructors seems bugged with std::complex<>
507 EIGEN_STRONG_INLINE scalar_multiple_op(const scalar_multiple_op& other) : m_other(other.m_other) { }
508 EIGEN_STRONG_INLINE scalar_multiple_op(const Scalar& other) : m_other(other) { }
509 EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a * m_other; }
510 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
511 { return internal::pmul(a, pset1<Packet>(m_other)); }
512 typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
513};
514template<typename Scalar>
515struct functor_traits<scalar_multiple_op<Scalar> >
516{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
517
518template<typename Scalar1, typename Scalar2>
519struct scalar_multiple2_op {
520 typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type;
521 EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { }
522 EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
523 EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }
524 typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
525};
526template<typename Scalar1,typename Scalar2>
527struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> >
528{ enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess = false }; };
529
538template<typename Scalar>
539struct scalar_quotient1_op {
540 typedef typename packet_traits<Scalar>::type Packet;
541 // FIXME default copy constructors seems bugged with std::complex<>
542 EIGEN_STRONG_INLINE scalar_quotient1_op(const scalar_quotient1_op& other) : m_other(other.m_other) { }
543 EIGEN_STRONG_INLINE scalar_quotient1_op(const Scalar& other) : m_other(other) {}
544 EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; }
545 EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
546 { return internal::pdiv(a, pset1<Packet>(m_other)); }
547 typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
548};
549template<typename Scalar>
550struct functor_traits<scalar_quotient1_op<Scalar> >
551{ enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };
552
553// nullary functors
554
555template<typename Scalar>
556struct scalar_constant_op {
557 typedef typename packet_traits<Scalar>::type Packet;
558 EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { }
559 EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { }
560 template<typename Index>
561 EIGEN_STRONG_INLINE const Scalar operator() (Index, Index = 0) const { return m_other; }
562 template<typename Index>
563 EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return internal::pset1<Packet>(m_other); }
564 const Scalar m_other;
565};
566template<typename Scalar>
567struct functor_traits<scalar_constant_op<Scalar> >
568// FIXME replace this packet test by a safe one
569{ enum { Cost = 1, PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; };
570
571template<typename Scalar> struct scalar_identity_op {
572 EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
573 template<typename Index>
574 EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { return row==col ? Scalar(1) : Scalar(0); }
575};
576template<typename Scalar>
577struct functor_traits<scalar_identity_op<Scalar> >
578{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; };
579
580template <typename Scalar, bool RandomAccess> struct linspaced_op_impl;
581
582// linear access for packet ops:
583// 1) initialization
584// base = [low, ..., low] + ([step, ..., step] * [-size, ..., 0])
585// 2) each step (where size is 1 for coeff access or PacketSize for packet access)
586// base += [size*step, ..., size*step]
587//
588// TODO: Perhaps it's better to initialize lazily (so not in the constructor but in packetOp)
589// in order to avoid the padd() in operator() ?
590template <typename Scalar>
591struct linspaced_op_impl<Scalar,false>
592{
593 typedef typename packet_traits<Scalar>::type Packet;
594
595 linspaced_op_impl(const Scalar& low, const Scalar& step) :
596 m_low(low), m_step(step),
597 m_packetStep(pset1<Packet>(packet_traits<Scalar>::size*step)),
598 m_base(padd(pset1<Packet>(low), pmul(pset1<Packet>(step),plset<Scalar>(-packet_traits<Scalar>::size)))) {}
599
600 template<typename Index>
601 EIGEN_STRONG_INLINE const Scalar operator() (Index i) const
602 {
603 m_base = padd(m_base, pset1<Packet>(m_step));
604 return m_low+Scalar(i)*m_step;
605 }
606
607 template<typename Index>
608 EIGEN_STRONG_INLINE const Packet packetOp(Index) const { return m_base = padd(m_base,m_packetStep); }
609
610 const Scalar m_low;
611 const Scalar m_step;
612 const Packet m_packetStep;
613 mutable Packet m_base;
614};
615
616// random access for packet ops:
617// 1) each step
618// [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) )
619template <typename Scalar>
620struct linspaced_op_impl<Scalar,true>
621{
622 typedef typename packet_traits<Scalar>::type Packet;
623
624 linspaced_op_impl(const Scalar& low, const Scalar& step) :
625 m_low(low), m_step(step),
626 m_lowPacket(pset1<Packet>(m_low)), m_stepPacket(pset1<Packet>(m_step)), m_interPacket(plset<Scalar>(0)) {}
627
628 template<typename Index>
629 EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; }
630
631 template<typename Index>
632 EIGEN_STRONG_INLINE const Packet packetOp(Index i) const
633 { return internal::padd(m_lowPacket, pmul(m_stepPacket, padd(pset1<Packet>(Scalar(i)),m_interPacket))); }
634
635 const Scalar m_low;
636 const Scalar m_step;
637 const Packet m_lowPacket;
638 const Packet m_stepPacket;
639 const Packet m_interPacket;
640};
641
642// ----- Linspace functor ----------------------------------------------------------------
643
644// Forward declaration (we default to random access which does not really give
645// us a speed gain when using packet access but it allows to use the functor in
646// nested expressions).
647template <typename Scalar, bool RandomAccess = true> struct linspaced_op;
648template <typename Scalar, bool RandomAccess> struct functor_traits< linspaced_op<Scalar,RandomAccess> >
649{ enum { Cost = 1, PacketAccess = packet_traits<Scalar>::HasSetLinear, IsRepeatable = true }; };
650template <typename Scalar, bool RandomAccess> struct linspaced_op
651{
652 typedef typename packet_traits<Scalar>::type Packet;
653 linspaced_op(const Scalar& low, const Scalar& high, DenseIndex num_steps) : impl((num_steps==1 ? high : low), (num_steps==1 ? Scalar() : (high-low)/Scalar(num_steps-1))) {}
654
655 template<typename Index>
656 EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); }
657
658 // We need this function when assigning e.g. a RowVectorXd to a MatrixXd since
659 // there row==0 and col is used for the actual iteration.
660 template<typename Index>
661 EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const
662 {
663 eigen_assert(col==0 || row==0);
664 return impl(col + row);
665 }
666
667 template<typename Index>
668 EIGEN_STRONG_INLINE const Packet packetOp(Index i) const { return impl.packetOp(i); }
669
670 // We need this function when assigning e.g. a RowVectorXd to a MatrixXd since
671 // there row==0 and col is used for the actual iteration.
672 template<typename Index>
673 EIGEN_STRONG_INLINE const Packet packetOp(Index row, Index col) const
674 {
675 eigen_assert(col==0 || row==0);
676 return impl.packetOp(col + row);
677 }
678
679 // This proxy object handles the actual required temporaries, the different
680 // implementations (random vs. sequential access) as well as the
681 // correct piping to size 2/4 packet operations.
682 const linspaced_op_impl<Scalar,RandomAccess> impl;
683};
684
685// all functors allow linear access, except scalar_identity_op. So we fix here a quick meta
686// to indicate whether a functor allows linear access, just always answering 'yes' except for
687// scalar_identity_op.
688// FIXME move this to functor_traits adding a functor_default
689template<typename Functor> struct functor_has_linear_access { enum { ret = 1 }; };
690template<typename Scalar> struct functor_has_linear_access<scalar_identity_op<Scalar> > { enum { ret = 0 }; };
691
692// In Eigen, any binary op (Product, CwiseBinaryOp) require the Lhs and Rhs to have the same scalar type, except for multiplication
693// where the mixing of different types is handled by scalar_product_traits
694// In particular, real * complex<real> is allowed.
695// FIXME move this to functor_traits adding a functor_default
696template<typename Functor> struct functor_is_product_like { enum { ret = 0 }; };
697template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
698template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_conj_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
699template<typename LhsScalar,typename RhsScalar> struct functor_is_product_like<scalar_quotient_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; };
700
701
706/* If you wonder why doing the pset1() in packetOp() is an optimization check scalar_multiple_op */
707template<typename Scalar>
708struct scalar_add_op {
709 typedef typename packet_traits<Scalar>::type Packet;
710 // FIXME default copy constructors seems bugged with std::complex<>
711 inline scalar_add_op(const scalar_add_op& other) : m_other(other.m_other) { }
712 inline scalar_add_op(const Scalar& other) : m_other(other) { }
713 inline Scalar operator() (const Scalar& a) const { return a + m_other; }
714 inline const Packet packetOp(const Packet& a) const
715 { return internal::padd(a, pset1<Packet>(m_other)); }
716 const Scalar m_other;
717};
718template<typename Scalar>
719struct functor_traits<scalar_add_op<Scalar> >
720{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; };
721
726template<typename Scalar> struct scalar_sqrt_op {
727 EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
728 inline const Scalar operator() (const Scalar& a) const { using std::sqrt; return sqrt(a); }
729 typedef typename packet_traits<Scalar>::type Packet;
730 inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
731};
732template<typename Scalar>
733struct functor_traits<scalar_sqrt_op<Scalar> >
734{ enum {
735 Cost = 5 * NumTraits<Scalar>::MulCost,
736 PacketAccess = packet_traits<Scalar>::HasSqrt
737 };
738};
739
744template<typename Scalar> struct scalar_cos_op {
745 EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
746 inline Scalar operator() (const Scalar& a) const { using std::cos; return cos(a); }
747 typedef typename packet_traits<Scalar>::type Packet;
748 inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
749};
750template<typename Scalar>
751struct functor_traits<scalar_cos_op<Scalar> >
752{
753 enum {
754 Cost = 5 * NumTraits<Scalar>::MulCost,
755 PacketAccess = packet_traits<Scalar>::HasCos
756 };
757};
758
763template<typename Scalar> struct scalar_sin_op {
764 EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
765 inline const Scalar operator() (const Scalar& a) const { using std::sin; return sin(a); }
766 typedef typename packet_traits<Scalar>::type Packet;
767 inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
768};
769template<typename Scalar>
770struct functor_traits<scalar_sin_op<Scalar> >
771{
772 enum {
773 Cost = 5 * NumTraits<Scalar>::MulCost,
774 PacketAccess = packet_traits<Scalar>::HasSin
775 };
776};
777
778
783template<typename Scalar> struct scalar_tan_op {
784 EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
785 inline const Scalar operator() (const Scalar& a) const { using std::tan; return tan(a); }
786 typedef typename packet_traits<Scalar>::type Packet;
787 inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
788};
789template<typename Scalar>
790struct functor_traits<scalar_tan_op<Scalar> >
791{
792 enum {
793 Cost = 5 * NumTraits<Scalar>::MulCost,
794 PacketAccess = packet_traits<Scalar>::HasTan
795 };
796};
797
802template<typename Scalar> struct scalar_acos_op {
803 EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
804 inline const Scalar operator() (const Scalar& a) const { using std::acos; return acos(a); }
805 typedef typename packet_traits<Scalar>::type Packet;
806 inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
807};
808template<typename Scalar>
809struct functor_traits<scalar_acos_op<Scalar> >
810{
811 enum {
812 Cost = 5 * NumTraits<Scalar>::MulCost,
813 PacketAccess = packet_traits<Scalar>::HasACos
814 };
815};
816
821template<typename Scalar> struct scalar_asin_op {
822 EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
823 inline const Scalar operator() (const Scalar& a) const { using std::asin; return asin(a); }
824 typedef typename packet_traits<Scalar>::type Packet;
825 inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
826};
827template<typename Scalar>
828struct functor_traits<scalar_asin_op<Scalar> >
829{
830 enum {
831 Cost = 5 * NumTraits<Scalar>::MulCost,
832 PacketAccess = packet_traits<Scalar>::HasASin
833 };
834};
835
840template<typename Scalar>
841struct scalar_pow_op {
842 // FIXME default copy constructors seems bugged with std::complex<>
843 inline scalar_pow_op(const scalar_pow_op& other) : m_exponent(other.m_exponent) { }
844 inline scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {}
845 inline Scalar operator() (const Scalar& a) const { return numext::pow(a, m_exponent); }
846 const Scalar m_exponent;
847};
848template<typename Scalar>
849struct functor_traits<scalar_pow_op<Scalar> >
850{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
851
856template<typename Scalar>
857struct scalar_inverse_mult_op {
858 scalar_inverse_mult_op(const Scalar& other) : m_other(other) {}
859 inline Scalar operator() (const Scalar& a) const { return m_other / a; }
860 template<typename Packet>
861 inline const Packet packetOp(const Packet& a) const
862 { return internal::pdiv(pset1<Packet>(m_other),a); }
863 Scalar m_other;
864};
865
870template<typename Scalar>
871struct scalar_inverse_op {
872 EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op)
873 inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
874 template<typename Packet>
875 inline const Packet packetOp(const Packet& a) const
876 { return internal::pdiv(pset1<Packet>(Scalar(1)),a); }
877};
878template<typename Scalar>
879struct functor_traits<scalar_inverse_op<Scalar> >
880{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };
881
886template<typename Scalar>
887struct scalar_square_op {
888 EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
889 inline Scalar operator() (const Scalar& a) const { return a*a; }
890 template<typename Packet>
891 inline const Packet packetOp(const Packet& a) const
892 { return internal::pmul(a,a); }
893};
894template<typename Scalar>
895struct functor_traits<scalar_square_op<Scalar> >
896{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
897
902template<typename Scalar>
903struct scalar_cube_op {
904 EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
905 inline Scalar operator() (const Scalar& a) const { return a*a*a; }
906 template<typename Packet>
907 inline const Packet packetOp(const Packet& a) const
908 { return internal::pmul(a,pmul(a,a)); }
909};
910template<typename Scalar>
911struct functor_traits<scalar_cube_op<Scalar> >
912{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
913
914// default functor traits for STL functors:
915
916template<typename T>
917struct functor_traits<std::multiplies<T> >
918{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
919
920template<typename T>
921struct functor_traits<std::divides<T> >
922{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
923
924template<typename T>
925struct functor_traits<std::plus<T> >
926{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
927
928template<typename T>
929struct functor_traits<std::minus<T> >
930{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
931
932template<typename T>
933struct functor_traits<std::negate<T> >
934{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
935
936template<typename T>
937struct functor_traits<std::logical_or<T> >
938{ enum { Cost = 1, PacketAccess = false }; };
939
940template<typename T>
941struct functor_traits<std::logical_and<T> >
942{ enum { Cost = 1, PacketAccess = false }; };
943
944template<typename T>
945struct functor_traits<std::logical_not<T> >
946{ enum { Cost = 1, PacketAccess = false }; };
947
948template<typename T>
949struct functor_traits<std::greater<T> >
950{ enum { Cost = 1, PacketAccess = false }; };
951
952template<typename T>
953struct functor_traits<std::less<T> >
954{ enum { Cost = 1, PacketAccess = false }; };
955
956template<typename T>
957struct functor_traits<std::greater_equal<T> >
958{ enum { Cost = 1, PacketAccess = false }; };
959
960template<typename T>
961struct functor_traits<std::less_equal<T> >
962{ enum { Cost = 1, PacketAccess = false }; };
963
964template<typename T>
965struct functor_traits<std::equal_to<T> >
966{ enum { Cost = 1, PacketAccess = false }; };
967
968template<typename T>
969struct functor_traits<std::not_equal_to<T> >
970{ enum { Cost = 1, PacketAccess = false }; };
971
972#if(__cplusplus < 201103L)
973// std::binder* are deprecated since c++11 and will be removed in c++17
974template<typename T>
975struct functor_traits<std::binder2nd<T> >
976{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
977
978template<typename T>
979struct functor_traits<std::binder1st<T> >
980{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
981#endif
982
983template<typename T>
984struct functor_traits<std::unary_negate<T> >
985{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
986
987template<typename T>
988struct functor_traits<std::binary_negate<T> >
989{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
990
991#ifdef EIGEN_STDEXT_SUPPORT
992
993template<typename T0,typename T1>
994struct functor_traits<std::project1st<T0,T1> >
995{ enum { Cost = 0, PacketAccess = false }; };
996
997template<typename T0,typename T1>
998struct functor_traits<std::project2nd<T0,T1> >
999{ enum { Cost = 0, PacketAccess = false }; };
1000
1001template<typename T0,typename T1>
1002struct functor_traits<std::select2nd<std::pair<T0,T1> > >
1003{ enum { Cost = 0, PacketAccess = false }; };
1004
1005template<typename T0,typename T1>
1006struct functor_traits<std::select1st<std::pair<T0,T1> > >
1007{ enum { Cost = 0, PacketAccess = false }; };
1008
1009template<typename T0,typename T1>
1010struct functor_traits<std::unary_compose<T0,T1> >
1011{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; };
1012
1013template<typename T0,typename T1,typename T2>
1014struct functor_traits<std::binary_compose<T0,T1,T2> >
1015{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess = false }; };
1016
1017#endif // EIGEN_STDEXT_SUPPORT
1018
1019// allow to add new functors and specializations of functor_traits from outside Eigen.
1020// this macro is really needed because functor_traits must be specialized after it is declared but before it is used...
1021#ifdef EIGEN_FUNCTORS_PLUGIN
1022#include EIGEN_FUNCTORS_PLUGIN
1023#endif
1024
1025} // end namespace internal
1026
1027} // end namespace Eigen
1028
1029#endif // EIGEN_FUNCTORS_H
Eigen::internal
Definition LDLT.h:18