10 #ifndef EIGEN_FUNCTORS_H 11 #define EIGEN_FUNCTORS_H 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); }
34 template<
typename Scalar>
35 struct functor_traits<scalar_sum_op<Scalar> > {
37 Cost = NumTraits<Scalar>::AddCost,
38 PacketAccess = packet_traits<Scalar>::HasAdd
47 template<
typename LhsScalar,
typename RhsScalar>
struct scalar_product_op {
50 Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
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); }
62 template<
typename LhsScalar,
typename RhsScalar>
63 struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {
65 Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2,
66 PacketAccess = scalar_product_op<LhsScalar,RhsScalar>::Vectorizable
75 template<
typename LhsScalar,
typename RhsScalar>
struct scalar_conj_product_op {
78 Conj = NumTraits<LhsScalar>::IsComplex
81 typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
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); }
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); }
91 template<
typename LhsScalar,
typename RhsScalar>
92 struct functor_traits<scalar_conj_product_op<LhsScalar,RhsScalar> > {
94 Cost = NumTraits<LhsScalar>::MulCost,
95 PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
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); }
114 template<
typename Scalar>
115 struct functor_traits<scalar_min_op<Scalar> > {
117 Cost = NumTraits<Scalar>::AddCost,
118 PacketAccess = packet_traits<Scalar>::HasMin
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); }
137 template<
typename Scalar>
138 struct functor_traits<scalar_max_op<Scalar> > {
140 Cost = NumTraits<Scalar>::AddCost,
141 PacketAccess = packet_traits<Scalar>::HasMax
150 template<
typename Scalar>
struct scalar_hypot_op {
151 EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op)
153 EIGEN_STRONG_INLINE
const Scalar operator() (
const Scalar& _x,
const Scalar& _y)
const 158 Scalar p = (max)(_x, _y);
159 Scalar q = (min)(_x, _y);
161 return p * sqrt(Scalar(1) + qp*qp);
164 template<
typename Scalar>
165 struct functor_traits<scalar_hypot_op<Scalar> > {
166 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 };
172 template<
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); }
176 template<
typename Scalar,
typename OtherScalar>
177 struct functor_traits<scalar_binary_pow_op<Scalar,OtherScalar> > {
178 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess =
false };
188 template<
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); }
195 template<
typename Scalar>
196 struct functor_traits<scalar_difference_op<Scalar> > {
198 Cost = NumTraits<Scalar>::AddCost,
199 PacketAccess = packet_traits<Scalar>::HasSub
208 template<
typename LhsScalar,
typename RhsScalar>
struct scalar_quotient_op {
211 Vectorizable = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv
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); }
220 template<
typename LhsScalar,
typename RhsScalar>
221 struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
223 Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost),
224 PacketAccess = scalar_quotient_op<LhsScalar,RhsScalar>::Vectorizable
235 struct 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; }
239 template<>
struct functor_traits<scalar_boolean_and_op> {
241 Cost = NumTraits<bool>::AddCost,
251 struct 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; }
255 template<>
struct functor_traits<scalar_boolean_or_op> {
257 Cost = NumTraits<bool>::AddCost,
269 template<
typename Scalar>
struct scalar_opposite_op {
270 EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op)
271 EIGEN_STRONG_INLINE
const Scalar operator() (
const Scalar& a)
const {
return -a; }
272 template<
typename Packet>
273 EIGEN_STRONG_INLINE
const Packet packetOp(
const Packet& a)
const 274 {
return internal::pnegate(a); }
276 template<
typename Scalar>
277 struct functor_traits<scalar_opposite_op<Scalar> >
279 Cost = NumTraits<Scalar>::AddCost,
280 PacketAccess = packet_traits<Scalar>::HasNegate };
288 template<
typename Scalar>
struct scalar_abs_op {
289 EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
290 typedef typename NumTraits<Scalar>::Real result_type;
291 EIGEN_STRONG_INLINE
const result_type operator() (
const Scalar& a)
const {
using std::abs;
return abs(a); }
292 template<
typename Packet>
293 EIGEN_STRONG_INLINE
const Packet packetOp(
const Packet& a)
const 294 {
return internal::pabs(a); }
296 template<
typename Scalar>
297 struct functor_traits<scalar_abs_op<Scalar> >
300 Cost = NumTraits<Scalar>::AddCost,
301 PacketAccess = packet_traits<Scalar>::HasAbs
310 template<
typename Scalar>
struct scalar_abs2_op {
311 EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
312 typedef typename NumTraits<Scalar>::Real result_type;
313 EIGEN_STRONG_INLINE
const result_type operator() (
const Scalar& a)
const {
return numext::abs2(a); }
314 template<
typename Packet>
315 EIGEN_STRONG_INLINE
const Packet packetOp(
const Packet& a)
const 316 {
return internal::pmul(a,a); }
318 template<
typename Scalar>
319 struct functor_traits<scalar_abs2_op<Scalar> >
320 {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; };
327 template<
typename Scalar>
struct scalar_conjugate_op {
328 EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
329 EIGEN_STRONG_INLINE
const Scalar operator() (
const Scalar& a)
const {
using numext::conj;
return conj(a); }
330 template<
typename Packet>
331 EIGEN_STRONG_INLINE
const Packet packetOp(
const Packet& a)
const {
return internal::pconj(a); }
333 template<
typename Scalar>
334 struct functor_traits<scalar_conjugate_op<Scalar> >
337 Cost = NumTraits<Scalar>::IsComplex ? NumTraits<Scalar>::AddCost : 0,
338 PacketAccess = packet_traits<Scalar>::HasConj
347 template<
typename Scalar,
typename NewType>
348 struct scalar_cast_op {
349 EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
350 typedef NewType result_type;
351 EIGEN_STRONG_INLINE
const NewType operator() (
const Scalar& a)
const {
return cast<Scalar, NewType>(a); }
353 template<
typename Scalar,
typename NewType>
354 struct functor_traits<scalar_cast_op<Scalar,NewType> >
355 {
enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess =
false }; };
362 template<
typename Scalar>
363 struct scalar_real_op {
364 EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
365 typedef typename NumTraits<Scalar>::Real result_type;
366 EIGEN_STRONG_INLINE result_type operator() (
const Scalar& a)
const {
return numext::real(a); }
368 template<
typename Scalar>
369 struct functor_traits<scalar_real_op<Scalar> >
370 {
enum { Cost = 0, PacketAccess =
false }; };
377 template<
typename Scalar>
378 struct scalar_imag_op {
379 EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
380 typedef typename NumTraits<Scalar>::Real result_type;
381 EIGEN_STRONG_INLINE result_type operator() (
const Scalar& a)
const {
return numext::imag(a); }
383 template<
typename Scalar>
384 struct functor_traits<scalar_imag_op<Scalar> >
385 {
enum { Cost = 0, PacketAccess =
false }; };
392 template<
typename Scalar>
393 struct scalar_real_ref_op {
394 EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
395 typedef typename NumTraits<Scalar>::Real result_type;
396 EIGEN_STRONG_INLINE result_type& operator() (
const Scalar& a)
const {
return numext::real_ref(*const_cast<Scalar*>(&a)); }
398 template<
typename Scalar>
399 struct functor_traits<scalar_real_ref_op<Scalar> >
400 {
enum { Cost = 0, PacketAccess =
false }; };
407 template<
typename Scalar>
408 struct scalar_imag_ref_op {
409 EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
410 typedef typename NumTraits<Scalar>::Real result_type;
411 EIGEN_STRONG_INLINE result_type& operator() (
const Scalar& a)
const {
return numext::imag_ref(*const_cast<Scalar*>(&a)); }
413 template<
typename Scalar>
414 struct functor_traits<scalar_imag_ref_op<Scalar> >
415 {
enum { Cost = 0, PacketAccess =
false }; };
423 template<
typename Scalar>
struct scalar_exp_op {
424 EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
425 inline const Scalar operator() (
const Scalar& a)
const {
using std::exp;
return exp(a); }
426 typedef typename packet_traits<Scalar>::type Packet;
427 inline Packet packetOp(
const Packet& a)
const {
return internal::pexp(a); }
429 template<
typename Scalar>
430 struct functor_traits<scalar_exp_op<Scalar> >
431 {
enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; };
439 template<
typename Scalar>
struct scalar_log_op {
440 EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
441 inline const Scalar operator() (
const Scalar& a)
const {
using std::log;
return log(a); }
442 typedef typename packet_traits<Scalar>::type Packet;
443 inline Packet packetOp(
const Packet& a)
const {
return internal::plog(a); }
445 template<
typename Scalar>
446 struct functor_traits<scalar_log_op<Scalar> >
447 {
enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };
462 template<
typename Scalar>
463 struct scalar_multiple_op {
464 typedef typename packet_traits<Scalar>::type Packet;
466 EIGEN_STRONG_INLINE scalar_multiple_op(
const scalar_multiple_op& other) : m_other(other.m_other) { }
467 EIGEN_STRONG_INLINE scalar_multiple_op(
const Scalar& other) : m_other(other) { }
468 EIGEN_STRONG_INLINE Scalar operator() (
const Scalar& a)
const {
return a * m_other; }
469 EIGEN_STRONG_INLINE
const Packet packetOp(
const Packet& a)
const 470 {
return internal::pmul(a, pset1<Packet>(m_other)); }
471 typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
473 template<
typename Scalar>
474 struct functor_traits<scalar_multiple_op<Scalar> >
475 {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
477 template<
typename Scalar1,
typename Scalar2>
478 struct scalar_multiple2_op {
479 typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type;
480 EIGEN_STRONG_INLINE scalar_multiple2_op(
const scalar_multiple2_op& other) : m_other(other.m_other) { }
481 EIGEN_STRONG_INLINE scalar_multiple2_op(
const Scalar2& other) : m_other(other) { }
482 EIGEN_STRONG_INLINE result_type operator() (
const Scalar1& a)
const {
return a * m_other; }
483 typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
485 template<
typename Scalar1,
typename Scalar2>
486 struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> >
487 {
enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess =
false }; };
497 template<
typename Scalar>
498 struct scalar_quotient1_op {
499 typedef typename packet_traits<Scalar>::type Packet;
501 EIGEN_STRONG_INLINE scalar_quotient1_op(
const scalar_quotient1_op& other) : m_other(other.m_other) { }
502 EIGEN_STRONG_INLINE scalar_quotient1_op(
const Scalar& other) : m_other(other) {}
503 EIGEN_STRONG_INLINE Scalar operator() (
const Scalar& a)
const {
return a / m_other; }
504 EIGEN_STRONG_INLINE
const Packet packetOp(
const Packet& a)
const 505 {
return internal::pdiv(a, pset1<Packet>(m_other)); }
506 typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
508 template<
typename Scalar>
509 struct functor_traits<scalar_quotient1_op<Scalar> >
510 {
enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };
514 template<
typename Scalar>
515 struct scalar_constant_op {
516 typedef typename packet_traits<Scalar>::type Packet;
517 EIGEN_STRONG_INLINE scalar_constant_op(
const scalar_constant_op& other) : m_other(other.m_other) { }
518 EIGEN_STRONG_INLINE scalar_constant_op(
const Scalar& other) : m_other(other) { }
519 template<
typename Index>
520 EIGEN_STRONG_INLINE
const Scalar operator() (Index, Index = 0)
const {
return m_other; }
521 template<
typename Index>
522 EIGEN_STRONG_INLINE
const Packet packetOp(Index, Index = 0)
const {
return internal::pset1<Packet>(m_other); }
523 const Scalar m_other;
525 template<
typename Scalar>
526 struct functor_traits<scalar_constant_op<Scalar> >
528 {
enum { Cost = 1, PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable =
true }; };
530 template<
typename Scalar>
struct scalar_identity_op {
531 EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
532 template<
typename Index>
533 EIGEN_STRONG_INLINE
const Scalar operator() (Index row, Index col)
const {
return row==col ? Scalar(1) : Scalar(0); }
535 template<
typename Scalar>
536 struct functor_traits<scalar_identity_op<Scalar> >
537 {
enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess =
false, IsRepeatable =
true }; };
539 template <
typename Scalar,
bool RandomAccess>
struct linspaced_op_impl;
549 template <
typename Scalar>
550 struct linspaced_op_impl<Scalar,false>
552 typedef typename packet_traits<Scalar>::type Packet;
554 linspaced_op_impl(
const Scalar& low,
const Scalar& step) :
555 m_low(low), m_step(step),
556 m_packetStep(pset1<Packet>(packet_traits<Scalar>::size*step)),
557 m_base(padd(pset1<Packet>(low), pmul(pset1<Packet>(step),plset<Scalar>(-packet_traits<Scalar>::size)))) {}
559 template<
typename Index>
560 EIGEN_STRONG_INLINE
const Scalar operator() (Index i)
const 562 m_base = padd(m_base, pset1<Packet>(m_step));
563 return m_low+Scalar(i)*m_step;
566 template<
typename Index>
567 EIGEN_STRONG_INLINE
const Packet packetOp(Index)
const {
return m_base = padd(m_base,m_packetStep); }
571 const Packet m_packetStep;
572 mutable Packet m_base;
578 template <
typename Scalar>
579 struct linspaced_op_impl<Scalar,true>
581 typedef typename packet_traits<Scalar>::type Packet;
583 linspaced_op_impl(
const Scalar& low,
const Scalar& step) :
584 m_low(low), m_step(step),
585 m_lowPacket(pset1<Packet>(m_low)), m_stepPacket(pset1<Packet>(m_step)), m_interPacket(plset<Scalar>(0)) {}
587 template<
typename Index>
588 EIGEN_STRONG_INLINE
const Scalar operator() (Index i)
const {
return m_low+i*m_step; }
590 template<
typename Index>
591 EIGEN_STRONG_INLINE
const Packet packetOp(Index i)
const 592 {
return internal::padd(m_lowPacket, pmul(m_stepPacket, padd(pset1<Packet>(Scalar(i)),m_interPacket))); }
596 const Packet m_lowPacket;
597 const Packet m_stepPacket;
598 const Packet m_interPacket;
606 template <
typename Scalar,
bool RandomAccess = true>
struct linspaced_op;
607 template <
typename Scalar,
bool RandomAccess>
struct functor_traits< linspaced_op<Scalar,RandomAccess> >
608 {
enum { Cost = 1, PacketAccess = packet_traits<Scalar>::HasSetLinear, IsRepeatable =
true }; };
609 template <
typename Scalar,
bool RandomAccess>
struct linspaced_op
611 typedef typename packet_traits<Scalar>::type Packet;
612 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))) {}
614 template<
typename Index>
615 EIGEN_STRONG_INLINE
const Scalar operator() (Index i)
const {
return impl(i); }
619 template<
typename Index>
620 EIGEN_STRONG_INLINE
const Scalar operator() (Index row, Index col)
const 622 eigen_assert(col==0 || row==0);
623 return impl(col + row);
626 template<
typename Index>
627 EIGEN_STRONG_INLINE
const Packet packetOp(Index i)
const {
return impl.packetOp(i); }
631 template<
typename Index>
632 EIGEN_STRONG_INLINE
const Packet packetOp(Index row, Index col)
const 634 eigen_assert(col==0 || row==0);
635 return impl.packetOp(col + row);
641 const linspaced_op_impl<Scalar,RandomAccess> impl;
648 template<
typename Functor>
struct functor_has_linear_access {
enum { ret = 1 }; };
649 template<
typename Scalar>
struct functor_has_linear_access<scalar_identity_op<Scalar> > {
enum { ret = 0 }; };
655 template<
typename Functor>
struct functor_is_product_like {
enum { ret = 0 }; };
656 template<
typename LhsScalar,
typename RhsScalar>
struct functor_is_product_like<scalar_product_op<LhsScalar,RhsScalar> > {
enum { ret = 1 }; };
657 template<
typename LhsScalar,
typename RhsScalar>
struct functor_is_product_like<scalar_conj_product_op<LhsScalar,RhsScalar> > {
enum { ret = 1 }; };
658 template<
typename LhsScalar,
typename RhsScalar>
struct functor_is_product_like<scalar_quotient_op<LhsScalar,RhsScalar> > {
enum { ret = 1 }; };
666 template<
typename Scalar>
667 struct scalar_add_op {
668 typedef typename packet_traits<Scalar>::type Packet;
670 inline scalar_add_op(
const scalar_add_op& other) : m_other(other.m_other) { }
671 inline scalar_add_op(
const Scalar& other) : m_other(other) { }
672 inline Scalar operator() (
const Scalar& a)
const {
return a + m_other; }
673 inline const Packet packetOp(
const Packet& a)
const 674 {
return internal::padd(a, pset1<Packet>(m_other)); }
675 const Scalar m_other;
677 template<
typename Scalar>
678 struct functor_traits<scalar_add_op<Scalar> >
679 {
enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; };
685 template<
typename Scalar>
struct scalar_sqrt_op {
686 EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
687 inline const Scalar operator() (
const Scalar& a)
const {
using std::sqrt;
return sqrt(a); }
688 typedef typename packet_traits<Scalar>::type Packet;
689 inline Packet packetOp(
const Packet& a)
const {
return internal::psqrt(a); }
691 template<
typename Scalar>
692 struct functor_traits<scalar_sqrt_op<Scalar> >
694 Cost = 5 * NumTraits<Scalar>::MulCost,
695 PacketAccess = packet_traits<Scalar>::HasSqrt
703 template<
typename Scalar>
struct scalar_cos_op {
704 EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
705 inline Scalar operator() (
const Scalar& a)
const {
using std::cos;
return cos(a); }
706 typedef typename packet_traits<Scalar>::type Packet;
707 inline Packet packetOp(
const Packet& a)
const {
return internal::pcos(a); }
709 template<
typename Scalar>
710 struct functor_traits<scalar_cos_op<Scalar> >
713 Cost = 5 * NumTraits<Scalar>::MulCost,
714 PacketAccess = packet_traits<Scalar>::HasCos
722 template<
typename Scalar>
struct scalar_sin_op {
723 EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
724 inline const Scalar operator() (
const Scalar& a)
const {
using std::sin;
return sin(a); }
725 typedef typename packet_traits<Scalar>::type Packet;
726 inline Packet packetOp(
const Packet& a)
const {
return internal::psin(a); }
728 template<
typename Scalar>
729 struct functor_traits<scalar_sin_op<Scalar> >
732 Cost = 5 * NumTraits<Scalar>::MulCost,
733 PacketAccess = packet_traits<Scalar>::HasSin
742 template<
typename Scalar>
struct scalar_tan_op {
743 EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
744 inline const Scalar operator() (
const Scalar& a)
const {
using std::tan;
return tan(a); }
745 typedef typename packet_traits<Scalar>::type Packet;
746 inline Packet packetOp(
const Packet& a)
const {
return internal::ptan(a); }
748 template<
typename Scalar>
749 struct functor_traits<scalar_tan_op<Scalar> >
752 Cost = 5 * NumTraits<Scalar>::MulCost,
753 PacketAccess = packet_traits<Scalar>::HasTan
761 template<
typename Scalar>
struct scalar_acos_op {
762 EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
763 inline const Scalar operator() (
const Scalar& a)
const {
using std::acos;
return acos(a); }
764 typedef typename packet_traits<Scalar>::type Packet;
765 inline Packet packetOp(
const Packet& a)
const {
return internal::pacos(a); }
767 template<
typename Scalar>
768 struct functor_traits<scalar_acos_op<Scalar> >
771 Cost = 5 * NumTraits<Scalar>::MulCost,
772 PacketAccess = packet_traits<Scalar>::HasACos
780 template<
typename Scalar>
struct scalar_asin_op {
781 EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
782 inline const Scalar operator() (
const Scalar& a)
const {
using std::asin;
return asin(a); }
783 typedef typename packet_traits<Scalar>::type Packet;
784 inline Packet packetOp(
const Packet& a)
const {
return internal::pasin(a); }
786 template<
typename Scalar>
787 struct functor_traits<scalar_asin_op<Scalar> >
790 Cost = 5 * NumTraits<Scalar>::MulCost,
791 PacketAccess = packet_traits<Scalar>::HasASin
799 template<
typename Scalar>
800 struct scalar_pow_op {
802 inline scalar_pow_op(
const scalar_pow_op& other) : m_exponent(other.m_exponent) { }
803 inline scalar_pow_op(
const Scalar& exponent) : m_exponent(exponent) {}
804 inline Scalar operator() (
const Scalar& a)
const {
return numext::pow(a, m_exponent); }
805 const Scalar m_exponent;
807 template<
typename Scalar>
808 struct functor_traits<scalar_pow_op<Scalar> >
809 {
enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess =
false }; };
815 template<
typename Scalar>
816 struct scalar_inverse_mult_op {
817 scalar_inverse_mult_op(
const Scalar& other) : m_other(other) {}
818 inline Scalar operator() (
const Scalar& a)
const {
return m_other / a; }
819 template<
typename Packet>
820 inline const Packet packetOp(
const Packet& a)
const 821 {
return internal::pdiv(pset1<Packet>(m_other),a); }
829 template<
typename Scalar>
830 struct scalar_inverse_op {
831 EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op)
832 inline Scalar operator() (
const Scalar& a)
const {
return Scalar(1)/a; }
833 template<
typename Packet>
834 inline const Packet packetOp(
const Packet& a)
const 835 {
return internal::pdiv(pset1<Packet>(Scalar(1)),a); }
837 template<
typename Scalar>
838 struct functor_traits<scalar_inverse_op<Scalar> >
839 {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };
845 template<
typename Scalar>
846 struct scalar_square_op {
847 EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
848 inline Scalar operator() (
const Scalar& a)
const {
return a*a; }
849 template<
typename Packet>
850 inline const Packet packetOp(
const Packet& a)
const 851 {
return internal::pmul(a,a); }
853 template<
typename Scalar>
854 struct functor_traits<scalar_square_op<Scalar> >
855 {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
861 template<
typename Scalar>
862 struct scalar_cube_op {
863 EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
864 inline Scalar operator() (
const Scalar& a)
const {
return a*a*a; }
865 template<
typename Packet>
866 inline const Packet packetOp(
const Packet& a)
const 867 {
return internal::pmul(a,pmul(a,a)); }
869 template<
typename Scalar>
870 struct functor_traits<scalar_cube_op<Scalar> >
871 {
enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
876 struct functor_traits<
std::multiplies<T> >
877 {
enum { Cost = NumTraits<T>::MulCost, PacketAccess =
false }; };
880 struct functor_traits<
std::divides<T> >
881 {
enum { Cost = NumTraits<T>::MulCost, PacketAccess =
false }; };
884 struct functor_traits<
std::plus<T> >
885 {
enum { Cost = NumTraits<T>::AddCost, PacketAccess =
false }; };
888 struct functor_traits<
std::minus<T> >
889 {
enum { Cost = NumTraits<T>::AddCost, PacketAccess =
false }; };
892 struct functor_traits<
std::negate<T> >
893 {
enum { Cost = NumTraits<T>::AddCost, PacketAccess =
false }; };
896 struct functor_traits<
std::logical_or<T> >
897 {
enum { Cost = 1, PacketAccess =
false }; };
900 struct functor_traits<
std::logical_and<T> >
901 {
enum { Cost = 1, PacketAccess =
false }; };
904 struct functor_traits<
std::logical_not<T> >
905 {
enum { Cost = 1, PacketAccess =
false }; };
908 struct functor_traits<
std::greater<T> >
909 {
enum { Cost = 1, PacketAccess =
false }; };
912 struct functor_traits<
std::less<T> >
913 {
enum { Cost = 1, PacketAccess =
false }; };
916 struct functor_traits<
std::greater_equal<T> >
917 {
enum { Cost = 1, PacketAccess =
false }; };
920 struct functor_traits<
std::less_equal<T> >
921 {
enum { Cost = 1, PacketAccess =
false }; };
924 struct functor_traits<
std::equal_to<T> >
925 {
enum { Cost = 1, PacketAccess =
false }; };
928 struct functor_traits<
std::not_equal_to<T> >
929 {
enum { Cost = 1, PacketAccess =
false }; };
932 struct functor_traits<
std::binder2nd<T> >
933 {
enum { Cost = functor_traits<T>::Cost, PacketAccess =
false }; };
936 struct functor_traits<
std::binder1st<T> >
937 {
enum { Cost = functor_traits<T>::Cost, PacketAccess =
false }; };
940 struct functor_traits<
std::unary_negate<T> >
941 {
enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess =
false }; };
944 struct functor_traits<
std::binary_negate<T> >
945 {
enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess =
false }; };
947 #ifdef EIGEN_STDEXT_SUPPORT 949 template<
typename T0,
typename T1>
950 struct functor_traits<
std::project1st<T0,T1> >
951 {
enum { Cost = 0, PacketAccess =
false }; };
953 template<
typename T0,
typename T1>
954 struct functor_traits<
std::project2nd<T0,T1> >
955 {
enum { Cost = 0, PacketAccess =
false }; };
957 template<
typename T0,
typename T1>
958 struct functor_traits<
std::select2nd<std::pair<T0,T1> > >
959 {
enum { Cost = 0, PacketAccess =
false }; };
961 template<
typename T0,
typename T1>
962 struct functor_traits<
std::select1st<std::pair<T0,T1> > >
963 {
enum { Cost = 0, PacketAccess =
false }; };
965 template<
typename T0,
typename T1>
966 struct functor_traits<
std::unary_compose<T0,T1> >
967 {
enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess =
false }; };
969 template<
typename T0,
typename T1,
typename T2>
970 struct functor_traits<
std::binary_compose<T0,T1,T2> >
971 {
enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess =
false }; };
973 #endif // EIGEN_STDEXT_SUPPORT 977 #ifdef EIGEN_FUNCTORS_PLUGIN 978 #include EIGEN_FUNCTORS_PLUGIN 985 #endif // EIGEN_FUNCTORS_H
Definition: StdDeque.h:58
Definition: Eigen_Colamd.h:54