source: pacpussensors/trunk/Vislab/lib3dv/eigen/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h@ 136

Last change on this file since 136 was 136, checked in by ldecherf, 7 years ago

Doc
File size: 25.5 KB
Line 
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2009 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_AUTODIFF_SCALAR_H
11#define EIGEN_AUTODIFF_SCALAR_H
12
13namespace Eigen {
14
15namespace internal {
16
17template<typename A, typename B>
18struct make_coherent_impl {
19 static void run(A&, B&) {}
20};
21
22// resize a to match b is a.size()==0, and conversely.
23template<typename A, typename B>
24void make_coherent(const A& a, const B&b)
25{
26 make_coherent_impl<A,B>::run(a.const_cast_derived(), b.const_cast_derived());
27}
28
29template<typename _DerType, bool Enable> struct auto_diff_special_op;
30
31} // end namespace internal
32
33/** \class AutoDiffScalar
34 * \brief A scalar type replacement with automatic differentation capability
35 *
36 * \param _DerType the vector type used to store/represent the derivatives. The base scalar type
37 * as well as the number of derivatives to compute are determined from this type.
38 * Typical choices include, e.g., \c Vector4f for 4 derivatives, or \c VectorXf
39 * if the number of derivatives is not known at compile time, and/or, the number
40 * of derivatives is large.
41 * Note that _DerType can also be a reference (e.g., \c VectorXf&) to wrap a
42 * existing vector into an AutoDiffScalar.
43 * Finally, _DerType can also be any Eigen compatible expression.
44 *
45 * This class represents a scalar value while tracking its respective derivatives using Eigen's expression
46 * template mechanism.
47 *
48 * It supports the following list of global math function:
49 * - std::abs, std::sqrt, std::pow, std::exp, std::log, std::sin, std::cos,
50 * - internal::abs, internal::sqrt, numext::pow, internal::exp, internal::log, internal::sin, internal::cos,
51 * - internal::conj, internal::real, internal::imag, numext::abs2.
52 *
53 * AutoDiffScalar can be used as the scalar type of an Eigen::Matrix object. However,
54 * in that case, the expression template mechanism only occurs at the top Matrix level,
55 * while derivatives are computed right away.
56 *
57 */
58
59template<typename _DerType>
60class AutoDiffScalar
61 : public internal::auto_diff_special_op
62 <_DerType, !internal::is_same<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar,
63 typename NumTraits<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar>::Real>::value>
64{
65 public:
66 typedef internal::auto_diff_special_op
67 <_DerType, !internal::is_same<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar,
68 typename NumTraits<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar>::Real>::value> Base;
69 typedef typename internal::remove_all<_DerType>::type DerType;
70 typedef typename internal::traits<DerType>::Scalar Scalar;
71 typedef typename NumTraits<Scalar>::Real Real;
72
73 using Base::operator+;
74 using Base::operator*;
75
76 /** Default constructor without any initialization. */
77 AutoDiffScalar() {}
78
79 /** Constructs an active scalar from its \a value,
80 and initializes the \a nbDer derivatives such that it corresponds to the \a derNumber -th variable */
81 AutoDiffScalar(const Scalar& value, int nbDer, int derNumber)
82 : m_value(value), m_derivatives(DerType::Zero(nbDer))
83 {
84 m_derivatives.coeffRef(derNumber) = Scalar(1);
85 }
86
87 /** Conversion from a scalar constant to an active scalar.
88 * The derivatives are set to zero. */
89 /*explicit*/ AutoDiffScalar(const Real& value)
90 : m_value(value)
91 {
92 if(m_derivatives.size()>0)
93 m_derivatives.setZero();
94 }
95
96 /** Constructs an active scalar from its \a value and derivatives \a der */
97 AutoDiffScalar(const Scalar& value, const DerType& der)
98 : m_value(value), m_derivatives(der)
99 {}
100
101 template<typename OtherDerType>
102 AutoDiffScalar(const AutoDiffScalar<OtherDerType>& other)
103 : m_value(other.value()), m_derivatives(other.derivatives())
104 {}
105
106 friend std::ostream & operator << (std::ostream & s, const AutoDiffScalar& a)
107 {
108 return s << a.value();
109 }
110
111 AutoDiffScalar(const AutoDiffScalar& other)
112 : m_value(other.value()), m_derivatives(other.derivatives())
113 {}
114
115 template<typename OtherDerType>
116 inline AutoDiffScalar& operator=(const AutoDiffScalar<OtherDerType>& other)
117 {
118 m_value = other.value();
119 m_derivatives = other.derivatives();
120 return *this;
121 }
122
123 inline AutoDiffScalar& operator=(const AutoDiffScalar& other)
124 {
125 m_value = other.value();
126 m_derivatives = other.derivatives();
127 return *this;
128 }
129
130// inline operator const Scalar& () const { return m_value; }
131// inline operator Scalar& () { return m_value; }
132
133 inline const Scalar& value() const { return m_value; }
134 inline Scalar& value() { return m_value; }
135
136 inline const DerType& derivatives() const { return m_derivatives; }
137 inline DerType& derivatives() { return m_derivatives; }
138
139 inline bool operator< (const Scalar& other) const { return m_value < other; }
140 inline bool operator<=(const Scalar& other) const { return m_value <= other; }
141 inline bool operator> (const Scalar& other) const { return m_value > other; }
142 inline bool operator>=(const Scalar& other) const { return m_value >= other; }
143 inline bool operator==(const Scalar& other) const { return m_value == other; }
144 inline bool operator!=(const Scalar& other) const { return m_value != other; }
145
146 friend inline bool operator< (const Scalar& a, const AutoDiffScalar& b) { return a < b.value(); }
147 friend inline bool operator<=(const Scalar& a, const AutoDiffScalar& b) { return a <= b.value(); }
148 friend inline bool operator> (const Scalar& a, const AutoDiffScalar& b) { return a > b.value(); }
149 friend inline bool operator>=(const Scalar& a, const AutoDiffScalar& b) { return a >= b.value(); }
150 friend inline bool operator==(const Scalar& a, const AutoDiffScalar& b) { return a == b.value(); }
151 friend inline bool operator!=(const Scalar& a, const AutoDiffScalar& b) { return a != b.value(); }
152
153 template<typename OtherDerType> inline bool operator< (const AutoDiffScalar<OtherDerType>& b) const { return m_value < b.value(); }
154 template<typename OtherDerType> inline bool operator<=(const AutoDiffScalar<OtherDerType>& b) const { return m_value <= b.value(); }
155 template<typename OtherDerType> inline bool operator> (const AutoDiffScalar<OtherDerType>& b) const { return m_value > b.value(); }
156 template<typename OtherDerType> inline bool operator>=(const AutoDiffScalar<OtherDerType>& b) const { return m_value >= b.value(); }
157 template<typename OtherDerType> inline bool operator==(const AutoDiffScalar<OtherDerType>& b) const { return m_value == b.value(); }
158 template<typename OtherDerType> inline bool operator!=(const AutoDiffScalar<OtherDerType>& b) const { return m_value != b.value(); }
159
160 inline const AutoDiffScalar<DerType&> operator+(const Scalar& other) const
161 {
162 return AutoDiffScalar<DerType&>(m_value + other, m_derivatives);
163 }
164
165 friend inline const AutoDiffScalar<DerType&> operator+(const Scalar& a, const AutoDiffScalar& b)
166 {
167 return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
168 }
169
170// inline const AutoDiffScalar<DerType&> operator+(const Real& other) const
171// {
172// return AutoDiffScalar<DerType&>(m_value + other, m_derivatives);
173// }
174
175// friend inline const AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar& b)
176// {
177// return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
178// }
179
180 inline AutoDiffScalar& operator+=(const Scalar& other)
181 {
182 value() += other;
183 return *this;
184 }
185
186 template<typename OtherDerType>
187 inline const AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>,const DerType,const typename internal::remove_all<OtherDerType>::type> >
188 operator+(const AutoDiffScalar<OtherDerType>& other) const
189 {
190 internal::make_coherent(m_derivatives, other.derivatives());
191 return AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>,const DerType,const typename internal::remove_all<OtherDerType>::type> >(
192 m_value + other.value(),
193 m_derivatives + other.derivatives());
194 }
195
196 template<typename OtherDerType>
197 inline AutoDiffScalar&
198 operator+=(const AutoDiffScalar<OtherDerType>& other)
199 {
200 (*this) = (*this) + other;
201 return *this;
202 }
203
204 inline const AutoDiffScalar<DerType&> operator-(const Scalar& b) const
205 {
206 return AutoDiffScalar<DerType&>(m_value - b, m_derivatives);
207 }
208
209 friend inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >
210 operator-(const Scalar& a, const AutoDiffScalar& b)
211 {
212 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >
213 (a - b.value(), -b.derivatives());
214 }
215
216 inline AutoDiffScalar& operator-=(const Scalar& other)
217 {
218 value() -= other;
219 return *this;
220 }
221
222 template<typename OtherDerType>
223 inline const AutoDiffScalar<CwiseBinaryOp<internal::scalar_difference_op<Scalar>, const DerType,const typename internal::remove_all<OtherDerType>::type> >
224 operator-(const AutoDiffScalar<OtherDerType>& other) const
225 {
226 internal::make_coherent(m_derivatives, other.derivatives());
227 return AutoDiffScalar<CwiseBinaryOp<internal::scalar_difference_op<Scalar>, const DerType,const typename internal::remove_all<OtherDerType>::type> >(
228 m_value - other.value(),
229 m_derivatives - other.derivatives());
230 }
231
232 template<typename OtherDerType>
233 inline AutoDiffScalar&
234 operator-=(const AutoDiffScalar<OtherDerType>& other)
235 {
236 *this = *this - other;
237 return *this;
238 }
239
240 inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >
241 operator-() const
242 {
243 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >(
244 -m_value,
245 -m_derivatives);
246 }
247
248 inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >
249 operator*(const Scalar& other) const
250 {
251 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >(
252 m_value * other,
253 (m_derivatives * other));
254 }
255
256 friend inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >
257 operator*(const Scalar& other, const AutoDiffScalar& a)
258 {
259 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >(
260 a.value() * other,
261 a.derivatives() * other);
262 }
263
264// inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
265// operator*(const Real& other) const
266// {
267// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
268// m_value * other,
269// (m_derivatives * other));
270// }
271//
272// friend inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
273// operator*(const Real& other, const AutoDiffScalar& a)
274// {
275// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
276// a.value() * other,
277// a.derivatives() * other);
278// }
279
280 inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >
281 operator/(const Scalar& other) const
282 {
283 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >(
284 m_value / other,
285 (m_derivatives * (Scalar(1)/other)));
286 }
287
288 friend inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >
289 operator/(const Scalar& other, const AutoDiffScalar& a)
290 {
291 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType> >(
292 other / a.value(),
293 a.derivatives() * (Scalar(-other) / (a.value()*a.value())));
294 }
295
296// inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
297// operator/(const Real& other) const
298// {
299// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
300// m_value / other,
301// (m_derivatives * (Real(1)/other)));
302// }
303//
304// friend inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
305// operator/(const Real& other, const AutoDiffScalar& a)
306// {
307// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
308// other / a.value(),
309// a.derivatives() * (-Real(1)/other));
310// }
311
312 template<typename OtherDerType>
313 inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>,
314 const CwiseBinaryOp<internal::scalar_difference_op<Scalar>,
315 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType>,
316 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const typename internal::remove_all<OtherDerType>::type > > > >
317 operator/(const AutoDiffScalar<OtherDerType>& other) const
318 {
319 internal::make_coherent(m_derivatives, other.derivatives());
320 return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>,
321 const CwiseBinaryOp<internal::scalar_difference_op<Scalar>,
322 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType>,
323 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const typename internal::remove_all<OtherDerType>::type > > > >(
324 m_value / other.value(),
325 ((m_derivatives * other.value()) - (m_value * other.derivatives()))
326 * (Scalar(1)/(other.value()*other.value())));
327 }
328
329 template<typename OtherDerType>
330 inline const AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>,
331 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType>,
332 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const typename internal::remove_all<OtherDerType>::type> > >
333 operator*(const AutoDiffScalar<OtherDerType>& other) const
334 {
335 internal::make_coherent(m_derivatives, other.derivatives());
336 return AutoDiffScalar<const CwiseBinaryOp<internal::scalar_sum_op<Scalar>,
337 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DerType>,
338 const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const typename internal::remove_all<OtherDerType>::type > > >(
339 m_value * other.value(),
340 (m_derivatives * other.value()) + (m_value * other.derivatives()));
341 }
342
343 inline AutoDiffScalar& operator*=(const Scalar& other)
344 {
345 *this = *this * other;
346 return *this;
347 }
348
349 template<typename OtherDerType>
350 inline AutoDiffScalar& operator*=(const AutoDiffScalar<OtherDerType>& other)
351 {
352 *this = *this * other;
353 return *this;
354 }
355
356 inline AutoDiffScalar& operator/=(const Scalar& other)
357 {
358 *this = *this / other;
359 return *this;
360 }
361
362 template<typename OtherDerType>
363 inline AutoDiffScalar& operator/=(const AutoDiffScalar<OtherDerType>& other)
364 {
365 *this = *this / other;
366 return *this;
367 }
368
369 protected:
370 Scalar m_value;
371 DerType m_derivatives;
372
373};
374
375namespace internal {
376
377template<typename _DerType>
378struct auto_diff_special_op<_DerType, true>
379// : auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real,
380// is_same<Scalar,typename NumTraits<Scalar>::Real>::value>
381{
382 typedef typename remove_all<_DerType>::type DerType;
383 typedef typename traits<DerType>::Scalar Scalar;
384 typedef typename NumTraits<Scalar>::Real Real;
385
386// typedef auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real,
387// is_same<Scalar,typename NumTraits<Scalar>::Real>::value> Base;
388
389// using Base::operator+;
390// using Base::operator+=;
391// using Base::operator-;
392// using Base::operator-=;
393// using Base::operator*;
394// using Base::operator*=;
395
396 const AutoDiffScalar<_DerType>& derived() const { return *static_cast<const AutoDiffScalar<_DerType>*>(this); }
397 AutoDiffScalar<_DerType>& derived() { return *static_cast<AutoDiffScalar<_DerType>*>(this); }
398
399
400 inline const AutoDiffScalar<DerType&> operator+(const Real& other) const
401 {
402 return AutoDiffScalar<DerType&>(derived().value() + other, derived().derivatives());
403 }
404
405 friend inline const AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar<_DerType>& b)
406 {
407 return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
408 }
409
410 inline AutoDiffScalar<_DerType>& operator+=(const Real& other)
411 {
412 derived().value() += other;
413 return derived();
414 }
415
416
417 inline const AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type >
418 operator*(const Real& other) const
419 {
420 return AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type >(
421 derived().value() * other,
422 derived().derivatives() * other);
423 }
424
425 friend inline const AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type >
426 operator*(const Real& other, const AutoDiffScalar<_DerType>& a)
427 {
428 return AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type >(
429 a.value() * other,
430 a.derivatives() * other);
431 }
432
433 inline AutoDiffScalar<_DerType>& operator*=(const Scalar& other)
434 {
435 *this = *this * other;
436 return derived();
437 }
438};
439
440template<typename _DerType>
441struct auto_diff_special_op<_DerType, false>
442{
443 void operator*() const;
444 void operator-() const;
445 void operator+() const;
446};
447
448template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols, typename B>
449struct make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>, B> {
450 typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> A;
451 static void run(A& a, B& b) {
452 if((A_Rows==Dynamic || A_Cols==Dynamic) && (a.size()==0))
453 {
454 a.resize(b.size());
455 a.setZero();
456 }
457 }
458};
459
460template<typename A, typename B_Scalar, int B_Rows, int B_Cols, int B_Options, int B_MaxRows, int B_MaxCols>
461struct make_coherent_impl<A, Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > {
462 typedef Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> B;
463 static void run(A& a, B& b) {
464 if((B_Rows==Dynamic || B_Cols==Dynamic) && (b.size()==0))
465 {
466 b.resize(a.size());
467 b.setZero();
468 }
469 }
470};
471
472template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols,
473 typename B_Scalar, int B_Rows, int B_Cols, int B_Options, int B_MaxRows, int B_MaxCols>
474struct make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>,
475 Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > {
476 typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> A;
477 typedef Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> B;
478 static void run(A& a, B& b) {
479 if((A_Rows==Dynamic || A_Cols==Dynamic) && (a.size()==0))
480 {
481 a.resize(b.size());
482 a.setZero();
483 }
484 else if((B_Rows==Dynamic || B_Cols==Dynamic) && (b.size()==0))
485 {
486 b.resize(a.size());
487 b.setZero();
488 }
489 }
490};
491
492template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols>
493struct scalar_product_traits<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>,A_Scalar>
494{
495 enum { Defined = 1 };
496 typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> ReturnType;
497};
498
499template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols>
500struct scalar_product_traits<A_Scalar, Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> >
501{
502 enum { Defined = 1 };
503 typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> ReturnType;
504};
505
506template<typename DerType>
507struct scalar_product_traits<AutoDiffScalar<DerType>,typename DerType::Scalar>
508{
509 enum { Defined = 1 };
510 typedef AutoDiffScalar<DerType> ReturnType;
511};
512
513template<typename DerType>
514struct scalar_product_traits<typename DerType::Scalar,AutoDiffScalar<DerType> >
515{
516 enum { Defined = 1 };
517 typedef AutoDiffScalar<DerType> ReturnType;
518};
519
520} // end namespace internal
521
522#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \
523 template<typename DerType> \
524 inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<typename Eigen::internal::traits<typename Eigen::internal::remove_all<DerType>::type>::Scalar>, const typename Eigen::internal::remove_all<DerType>::type> > \
525 FUNC(const Eigen::AutoDiffScalar<DerType>& x) { \
526 using namespace Eigen; \
527 typedef typename Eigen::internal::traits<typename Eigen::internal::remove_all<DerType>::type>::Scalar Scalar; \
528 typedef AutoDiffScalar<CwiseUnaryOp<Eigen::internal::scalar_multiple_op<Scalar>, const typename Eigen::internal::remove_all<DerType>::type> > ReturnType; \
529 CODE; \
530 }
531
532template<typename DerType>
533inline const AutoDiffScalar<DerType>& conj(const AutoDiffScalar<DerType>& x) { return x; }
534template<typename DerType>
535inline const AutoDiffScalar<DerType>& real(const AutoDiffScalar<DerType>& x) { return x; }
536template<typename DerType>
537inline typename DerType::Scalar imag(const AutoDiffScalar<DerType>&) { return 0.; }
538template<typename DerType, typename T>
539inline AutoDiffScalar<DerType> (min)(const AutoDiffScalar<DerType>& x, const T& y) { return (x <= y ? x : y); }
540template<typename DerType, typename T>
541inline AutoDiffScalar<DerType> (max)(const AutoDiffScalar<DerType>& x, const T& y) { return (x >= y ? x : y); }
542template<typename DerType, typename T>
543inline AutoDiffScalar<DerType> (min)(const T& x, const AutoDiffScalar<DerType>& y) { return (x < y ? x : y); }
544template<typename DerType, typename T>
545inline AutoDiffScalar<DerType> (max)(const T& x, const AutoDiffScalar<DerType>& y) { return (x > y ? x : y); }
546
547EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs,
548 using std::abs;
549 return ReturnType(abs(x.value()), x.derivatives() * (x.value()<0 ? -1 : 1) );)
550
551EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2,
552 using numext::abs2;
553 return ReturnType(abs2(x.value()), x.derivatives() * (Scalar(2)*x.value()));)
554
555EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sqrt,
556 using std::sqrt;
557 Scalar sqrtx = sqrt(x.value());
558 return ReturnType(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx));)
559
560EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos,
561 using std::cos;
562 using std::sin;
563 return ReturnType(cos(x.value()), x.derivatives() * (-sin(x.value())));)
564
565EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sin,
566 using std::sin;
567 using std::cos;
568 return ReturnType(sin(x.value()),x.derivatives() * cos(x.value()));)
569
570EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp,
571 using std::exp;
572 Scalar expx = exp(x.value());
573 return ReturnType(expx,x.derivatives() * expx);)
574
575EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(log,
576 using std::log;
577 return ReturnType(log(x.value()),x.derivatives() * (Scalar(1)/x.value()));)
578
579template<typename DerType>
580inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<typename Eigen::internal::traits<DerType>::Scalar>, const DerType> >
581pow(const Eigen::AutoDiffScalar<DerType>& x, typename Eigen::internal::traits<DerType>::Scalar y)
582{
583 using namespace Eigen;
584 typedef typename Eigen::internal::traits<DerType>::Scalar Scalar;
585 return AutoDiffScalar<CwiseUnaryOp<Eigen::internal::scalar_multiple_op<Scalar>, const DerType> >(
586 std::pow(x.value(),y),
587 x.derivatives() * (y * std::pow(x.value(),y-1)));
588}
589
590
591template<typename DerTypeA,typename DerTypeB>
592inline const AutoDiffScalar<Matrix<typename internal::traits<DerTypeA>::Scalar,Dynamic,1> >
593atan2(const AutoDiffScalar<DerTypeA>& a, const AutoDiffScalar<DerTypeB>& b)
594{
595 using std::atan2;
596 using std::max;
597 typedef typename internal::traits<DerTypeA>::Scalar Scalar;
598 typedef AutoDiffScalar<Matrix<Scalar,Dynamic,1> > PlainADS;
599 PlainADS ret;
600 ret.value() = atan2(a.value(), b.value());
601
602 Scalar tmp2 = a.value() * a.value();
603 Scalar tmp3 = b.value() * b.value();
604 Scalar tmp4 = tmp3/(tmp2+tmp3);
605
606 if (tmp4!=0)
607 ret.derivatives() = (a.derivatives() * b.value() - a.value() * b.derivatives()) * (tmp2+tmp3);
608
609 return ret;
610}
611
612EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tan,
613 using std::tan;
614 using std::cos;
615 return ReturnType(tan(x.value()),x.derivatives() * (Scalar(1)/numext::abs2(cos(x.value()))));)
616
617EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin,
618 using std::sqrt;
619 using std::asin;
620 return ReturnType(asin(x.value()),x.derivatives() * (Scalar(1)/sqrt(1-numext::abs2(x.value()))));)
621
622EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(acos,
623 using std::sqrt;
624 using std::acos;
625 return ReturnType(acos(x.value()),x.derivatives() * (Scalar(-1)/sqrt(1-numext::abs2(x.value()))));)
626
627#undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY
628
629template<typename DerType> struct NumTraits<AutoDiffScalar<DerType> >
630 : NumTraits< typename NumTraits<typename DerType::Scalar>::Real >
631{
632 typedef AutoDiffScalar<Matrix<typename NumTraits<typename DerType::Scalar>::Real,DerType::RowsAtCompileTime,DerType::ColsAtCompileTime> > Real;
633 typedef AutoDiffScalar<DerType> NonInteger;
634 typedef AutoDiffScalar<DerType> Nested;
635 enum{
636 RequireInitialization = 1
637 };
638};
639
640}
641
642#endif // EIGEN_AUTODIFF_SCALAR_H
Note: See TracBrowser for help on using the repository browser.