← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to extern/Eigen3/Eigen/src/Core/Functors.h

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/Eigen3/Eigen/src/Core/Functors.h
3
3
//
4
4
// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
5
5
//
6
 
// Eigen is free software; you can redistribute it and/or
7
 
// modify it under the terms of the GNU Lesser General Public
8
 
// License as published by the Free Software Foundation; either
9
 
// version 3 of the License, or (at your option) any later version.
10
 
//
11
 
// Alternatively, you can redistribute it and/or
12
 
// modify it under the terms of the GNU General Public License as
13
 
// published by the Free Software Foundation; either version 2 of
14
 
// the License, or (at your option) any later version.
15
 
//
16
 
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
17
 
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18
 
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
19
 
// GNU General Public License for more details.
20
 
//
21
 
// You should have received a copy of the GNU Lesser General Public
22
 
// License and a copy of the GNU General Public License along with
23
 
// Eigen. If not, see <http://www.gnu.org/licenses/>.
 
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/.
24
9
 
25
10
#ifndef EIGEN_FUNCTORS_H
26
11
#define EIGEN_FUNCTORS_H
27
12
 
 
13
namespace Eigen {
 
14
 
28
15
namespace internal {
29
16
 
30
17
// associative functors:
178
165
  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 };
179
166
};
180
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
 
181
180
// other binary functors:
182
181
 
183
182
/** \internal
220
219
  };
221
220
};
222
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
 
223
254
// unary functors:
224
255
 
225
256
/** \internal
249
280
template<typename Scalar> struct scalar_abs_op {
250
281
  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
251
282
  typedef typename NumTraits<Scalar>::Real result_type;
252
 
  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return abs(a); }
 
283
  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs(a); }
253
284
  template<typename Packet>
254
285
  EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
255
286
  { return internal::pabs(a); }
271
302
template<typename Scalar> struct scalar_abs2_op {
272
303
  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
273
304
  typedef typename NumTraits<Scalar>::Real result_type;
274
 
  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return abs2(a); }
 
305
  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs2(a); }
275
306
  template<typename Packet>
276
307
  EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
277
308
  { return internal::pmul(a,a); }
287
318
  */
288
319
template<typename Scalar> struct scalar_conjugate_op {
289
320
  EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
290
 
  EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return conj(a); }
 
321
  EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return internal::conj(a); }
291
322
  template<typename Packet>
292
323
  EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); }
293
324
};
324
355
struct scalar_real_op {
325
356
  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
326
357
  typedef typename NumTraits<Scalar>::Real result_type;
327
 
  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return real(a); }
 
358
  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::real(a); }
328
359
};
329
360
template<typename Scalar>
330
361
struct functor_traits<scalar_real_op<Scalar> >
339
370
struct scalar_imag_op {
340
371
  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
341
372
  typedef typename NumTraits<Scalar>::Real result_type;
342
 
  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return imag(a); }
 
373
  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::imag(a); }
343
374
};
344
375
template<typename Scalar>
345
376
struct functor_traits<scalar_imag_op<Scalar> >
354
385
struct scalar_real_ref_op {
355
386
  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
356
387
  typedef typename NumTraits<Scalar>::Real result_type;
357
 
  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return real_ref(*const_cast<Scalar*>(&a)); }
 
388
  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::real_ref(*const_cast<Scalar*>(&a)); }
358
389
};
359
390
template<typename Scalar>
360
391
struct functor_traits<scalar_real_ref_op<Scalar> >
369
400
struct scalar_imag_ref_op {
370
401
  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
371
402
  typedef typename NumTraits<Scalar>::Real result_type;
372
 
  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return imag_ref(*const_cast<Scalar*>(&a)); }
 
403
  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::imag_ref(*const_cast<Scalar*>(&a)); }
373
404
};
374
405
template<typename Scalar>
375
406
struct functor_traits<scalar_imag_ref_op<Scalar> >
383
414
  */
384
415
template<typename Scalar> struct scalar_exp_op {
385
416
  EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
386
 
  inline const Scalar operator() (const Scalar& a) const { return exp(a); }
 
417
  inline const Scalar operator() (const Scalar& a) const { return internal::exp(a); }
387
418
  typedef typename packet_traits<Scalar>::type Packet;
388
419
  inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
389
420
};
399
430
  */
400
431
template<typename Scalar> struct scalar_log_op {
401
432
  EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
402
 
  inline const Scalar operator() (const Scalar& a) const { return log(a); }
 
433
  inline const Scalar operator() (const Scalar& a) const { return internal::log(a); }
403
434
  typedef typename packet_traits<Scalar>::type Packet;
404
435
  inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
405
436
};
584
615
template <typename Scalar, bool RandomAccess> struct linspaced_op
585
616
{
586
617
  typedef typename packet_traits<Scalar>::type Packet;
587
 
  linspaced_op(Scalar low, Scalar high, int num_steps) : impl(low, (high-low)/(num_steps-1)) {}
 
618
  linspaced_op(Scalar low, Scalar high, int num_steps) : impl((num_steps==1 ? high : low), (num_steps==1 ? Scalar() : (high-low)/(num_steps-1))) {}
588
619
 
589
620
  template<typename Index>
590
621
  EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); }
657
688
  */
658
689
template<typename Scalar> struct scalar_sqrt_op {
659
690
  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
660
 
  inline const Scalar operator() (const Scalar& a) const { return sqrt(a); }
 
691
  inline const Scalar operator() (const Scalar& a) const { return internal::sqrt(a); }
661
692
  typedef typename packet_traits<Scalar>::type Packet;
662
693
  inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
663
694
};
675
706
  */
676
707
template<typename Scalar> struct scalar_cos_op {
677
708
  EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
678
 
  inline Scalar operator() (const Scalar& a) const { return cos(a); }
 
709
  inline Scalar operator() (const Scalar& a) const { return internal::cos(a); }
679
710
  typedef typename packet_traits<Scalar>::type Packet;
680
711
  inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
681
712
};
694
725
  */
695
726
template<typename Scalar> struct scalar_sin_op {
696
727
  EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
697
 
  inline const Scalar operator() (const Scalar& a) const { return sin(a); }
 
728
  inline const Scalar operator() (const Scalar& a) const { return internal::sin(a); }
698
729
  typedef typename packet_traits<Scalar>::type Packet;
699
730
  inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
700
731
};
714
745
  */
715
746
template<typename Scalar> struct scalar_tan_op {
716
747
  EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
717
 
  inline const Scalar operator() (const Scalar& a) const { return tan(a); }
 
748
  inline const Scalar operator() (const Scalar& a) const { return internal::tan(a); }
718
749
  typedef typename packet_traits<Scalar>::type Packet;
719
750
  inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
720
751
};
733
764
  */
734
765
template<typename Scalar> struct scalar_acos_op {
735
766
  EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
736
 
  inline const Scalar operator() (const Scalar& a) const { return acos(a); }
 
767
  inline const Scalar operator() (const Scalar& a) const { return internal::acos(a); }
737
768
  typedef typename packet_traits<Scalar>::type Packet;
738
769
  inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
739
770
};
752
783
  */
753
784
template<typename Scalar> struct scalar_asin_op {
754
785
  EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
755
 
  inline const Scalar operator() (const Scalar& a) const { return asin(a); }
 
786
  inline const Scalar operator() (const Scalar& a) const { return internal::asin(a); }
756
787
  typedef typename packet_traits<Scalar>::type Packet;
757
788
  inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
758
789
};
782
813
{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
783
814
 
784
815
/** \internal
 
816
  * \brief Template functor to compute the quotient between a scalar and array entries.
 
817
  * \sa class CwiseUnaryOp, Cwise::inverse()
 
818
  */
 
819
template<typename Scalar>
 
820
struct scalar_inverse_mult_op {
 
821
  scalar_inverse_mult_op(const Scalar& other) : m_other(other) {}
 
822
  inline Scalar operator() (const Scalar& a) const { return m_other / a; }
 
823
  template<typename Packet>
 
824
  inline const Packet packetOp(const Packet& a) const
 
825
  { return internal::pdiv(pset1<Packet>(m_other),a); }
 
826
  Scalar m_other;
 
827
};
 
828
 
 
829
/** \internal
785
830
  * \brief Template functor to compute the inverse of a scalar
786
831
  * \sa class CwiseUnaryOp, Cwise::inverse()
787
832
  */
939
984
 
940
985
} // end namespace internal
941
986
 
 
987
} // end namespace Eigen
 
988
 
942
989
#endif // EIGEN_FUNCTORS_H