AutoDiffScalar.h
Go to the documentation of this file.
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 
13 namespace Eigen {
14 
15 namespace internal {
16 
17 template<typename A, typename B>
19  static void run(A&, B&) {}
20 };
21 
22 // resize a to match b is a.size()==0, and conversely.
23 template<typename A, typename B>
24 void 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 
29 template<typename _DerType, bool Enable> struct auto_diff_special_op;
30 
31 } // end namespace internal
32 
33 template<typename _DerType> class AutoDiffScalar;
34 
35 template<typename NewDerType>
36 inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::Scalar& value, const NewDerType &der) {
38 }
39 
66 template<typename _DerType>
67 class AutoDiffScalar
69  <_DerType, !internal::is_same<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar,
70  typename NumTraits<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar>::Real>::value>
71 {
72  public:
78  typedef typename NumTraits<Scalar>::Real Real;
79 
80  using Base::operator+;
81  using Base::operator*;
82 
85 
88  AutoDiffScalar(const Scalar& value, int nbDer, int derNumber)
89  : m_value(value), m_derivatives(DerType::Zero(nbDer))
90  {
91  m_derivatives.coeffRef(derNumber) = Scalar(1);
92  }
93 
96  /*explicit*/ AutoDiffScalar(const Real& value)
97  : m_value(value)
98  {
99  if(m_derivatives.size()>0)
100  m_derivatives.setZero();
101  }
102 
104  AutoDiffScalar(const Scalar& value, const DerType& der)
105  : m_value(value), m_derivatives(der)
106  {}
107 
108  template<typename OtherDerType>
110 #ifndef EIGEN_PARSED_BY_DOXYGEN
111  , typename internal::enable_if<
114 #endif
115  )
116  : m_value(other.value()), m_derivatives(other.derivatives())
117  {}
118 
119  friend std::ostream & operator << (std::ostream & s, const AutoDiffScalar& a)
120  {
121  return s << a.value();
122  }
123 
125  : m_value(other.value()), m_derivatives(other.derivatives())
126  {}
127 
128  template<typename OtherDerType>
130  {
131  m_value = other.value();
132  m_derivatives = other.derivatives();
133  return *this;
134  }
135 
137  {
138  m_value = other.value();
139  m_derivatives = other.derivatives();
140  return *this;
141  }
142 
143  inline AutoDiffScalar& operator=(const Scalar& other)
144  {
145  m_value = other;
146  if(m_derivatives.size()>0)
147  m_derivatives.setZero();
148  return *this;
149  }
150 
151 // inline operator const Scalar& () const { return m_value; }
152 // inline operator Scalar& () { return m_value; }
153 
154  inline const Scalar& value() const { return m_value; }
155  inline Scalar& value() { return m_value; }
156 
157  inline const DerType& derivatives() const { return m_derivatives; }
158  inline DerType& derivatives() { return m_derivatives; }
159 
160  inline bool operator< (const Scalar& other) const { return m_value < other; }
161  inline bool operator<=(const Scalar& other) const { return m_value <= other; }
162  inline bool operator> (const Scalar& other) const { return m_value > other; }
163  inline bool operator>=(const Scalar& other) const { return m_value >= other; }
164  inline bool operator==(const Scalar& other) const { return m_value == other; }
165  inline bool operator!=(const Scalar& other) const { return m_value != other; }
166 
167  friend inline bool operator< (const Scalar& a, const AutoDiffScalar& b) { return a < b.value(); }
168  friend inline bool operator<=(const Scalar& a, const AutoDiffScalar& b) { return a <= b.value(); }
169  friend inline bool operator> (const Scalar& a, const AutoDiffScalar& b) { return a > b.value(); }
170  friend inline bool operator>=(const Scalar& a, const AutoDiffScalar& b) { return a >= b.value(); }
171  friend inline bool operator==(const Scalar& a, const AutoDiffScalar& b) { return a == b.value(); }
172  friend inline bool operator!=(const Scalar& a, const AutoDiffScalar& b) { return a != b.value(); }
173 
174  template<typename OtherDerType> inline bool operator< (const AutoDiffScalar<OtherDerType>& b) const { return m_value < b.value(); }
175  template<typename OtherDerType> inline bool operator<=(const AutoDiffScalar<OtherDerType>& b) const { return m_value <= b.value(); }
176  template<typename OtherDerType> inline bool operator> (const AutoDiffScalar<OtherDerType>& b) const { return m_value > b.value(); }
177  template<typename OtherDerType> inline bool operator>=(const AutoDiffScalar<OtherDerType>& b) const { return m_value >= b.value(); }
178  template<typename OtherDerType> inline bool operator==(const AutoDiffScalar<OtherDerType>& b) const { return m_value == b.value(); }
179  template<typename OtherDerType> inline bool operator!=(const AutoDiffScalar<OtherDerType>& b) const { return m_value != b.value(); }
180 
181  inline const AutoDiffScalar<DerType&> operator+(const Scalar& other) const
182  {
183  return AutoDiffScalar<DerType&>(m_value + other, m_derivatives);
184  }
185 
186  friend inline const AutoDiffScalar<DerType&> operator+(const Scalar& a, const AutoDiffScalar& b)
187  {
188  return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
189  }
190 
191 // inline const AutoDiffScalar<DerType&> operator+(const Real& other) const
192 // {
193 // return AutoDiffScalar<DerType&>(m_value + other, m_derivatives);
194 // }
195 
196 // friend inline const AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar& b)
197 // {
198 // return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
199 // }
200 
201  inline AutoDiffScalar& operator+=(const Scalar& other)
202  {
203  value() += other;
204  return *this;
205  }
206 
207  template<typename OtherDerType>
210  {
211  internal::make_coherent(m_derivatives, other.derivatives());
213  m_value + other.value(),
214  m_derivatives + other.derivatives());
215  }
216 
217  template<typename OtherDerType>
218  inline AutoDiffScalar&
220  {
221  (*this) = (*this) + other;
222  return *this;
223  }
224 
225  inline const AutoDiffScalar<DerType&> operator-(const Scalar& b) const
226  {
227  return AutoDiffScalar<DerType&>(m_value - b, m_derivatives);
228  }
229 
230  friend inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >
231  operator-(const Scalar& a, const AutoDiffScalar& b)
232  {
233  return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >
234  (a - b.value(), -b.derivatives());
235  }
236 
237  inline AutoDiffScalar& operator-=(const Scalar& other)
238  {
239  value() -= other;
240  return *this;
241  }
242 
243  template<typename OtherDerType>
246  {
247  internal::make_coherent(m_derivatives, other.derivatives());
249  m_value - other.value(),
250  m_derivatives - other.derivatives());
251  }
252 
253  template<typename OtherDerType>
254  inline AutoDiffScalar&
256  {
257  *this = *this - other;
258  return *this;
259  }
260 
261  inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >
262  operator-() const
263  {
264  return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType> >(
265  -m_value,
266  -m_derivatives);
267  }
268 
270  operator*(const Scalar& other) const
271  {
272  return MakeAutoDiffScalar(m_value * other, m_derivatives * other);
273  }
274 
276  operator*(const Scalar& other, const AutoDiffScalar& a)
277  {
278  return MakeAutoDiffScalar(a.value() * other, a.derivatives() * other);
279  }
280 
281 // inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
282 // operator*(const Real& other) const
283 // {
284 // return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
285 // m_value * other,
286 // (m_derivatives * other));
287 // }
288 //
289 // friend inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
290 // operator*(const Real& other, const AutoDiffScalar& a)
291 // {
292 // return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
293 // a.value() * other,
294 // a.derivatives() * other);
295 // }
296 
298  operator/(const Scalar& other) const
299  {
300  return MakeAutoDiffScalar(m_value / other, (m_derivatives * (Scalar(1)/other)));
301  }
302 
304  operator/(const Scalar& other, const AutoDiffScalar& a)
305  {
306  return MakeAutoDiffScalar(other / a.value(), a.derivatives() * (Scalar(-other) / (a.value()*a.value())));
307  }
308 
309 // inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
310 // operator/(const Real& other) const
311 // {
312 // return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
313 // m_value / other,
314 // (m_derivatives * (Real(1)/other)));
315 // }
316 //
317 // friend inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >
318 // operator/(const Real& other, const AutoDiffScalar& a)
319 // {
320 // return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >(
321 // other / a.value(),
322 // a.derivatives() * (-Real(1)/other));
323 // }
324 
325  template<typename OtherDerType>
331  {
332  internal::make_coherent(m_derivatives, other.derivatives());
333  return MakeAutoDiffScalar(
334  m_value / other.value(),
335  ((m_derivatives * other.value()) - (other.derivatives() * m_value))
336  * (Scalar(1)/(other.value()*other.value())));
337  }
338 
339  template<typename OtherDerType>
341  const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType,Scalar,product),
344  {
345  internal::make_coherent(m_derivatives, other.derivatives());
346  return MakeAutoDiffScalar(
347  m_value * other.value(),
348  (m_derivatives * other.value()) + (other.derivatives() * m_value));
349  }
350 
351  inline AutoDiffScalar& operator*=(const Scalar& other)
352  {
353  *this = *this * other;
354  return *this;
355  }
356 
357  template<typename OtherDerType>
359  {
360  *this = *this * other;
361  return *this;
362  }
363 
364  inline AutoDiffScalar& operator/=(const Scalar& other)
365  {
366  *this = *this / other;
367  return *this;
368  }
369 
370  template<typename OtherDerType>
372  {
373  *this = *this / other;
374  return *this;
375  }
376 
377  protected:
378  Scalar m_value;
379  DerType m_derivatives;
380 
381 };
382 
383 namespace internal {
384 
385 template<typename _DerType>
386 struct auto_diff_special_op<_DerType, true>
387 // : auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real,
388 // is_same<Scalar,typename NumTraits<Scalar>::Real>::value>
389 {
391  typedef typename traits<DerType>::Scalar Scalar;
392  typedef typename NumTraits<Scalar>::Real Real;
393 
394 // typedef auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real,
395 // is_same<Scalar,typename NumTraits<Scalar>::Real>::value> Base;
396 
397 // using Base::operator+;
398 // using Base::operator+=;
399 // using Base::operator-;
400 // using Base::operator-=;
401 // using Base::operator*;
402 // using Base::operator*=;
403 
404  const AutoDiffScalar<_DerType>& derived() const { return *static_cast<const AutoDiffScalar<_DerType>*>(this); }
405  AutoDiffScalar<_DerType>& derived() { return *static_cast<AutoDiffScalar<_DerType>*>(this); }
406 
407 
408  inline const AutoDiffScalar<DerType&> operator+(const Real& other) const
409  {
410  return AutoDiffScalar<DerType&>(derived().value() + other, derived().derivatives());
411  }
412 
413  friend inline const AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar<_DerType>& b)
414  {
415  return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
416  }
417 
418  inline AutoDiffScalar<_DerType>& operator+=(const Real& other)
419  {
420  derived().value() += other;
421  return derived();
422  }
423 
424 
426  operator*(const Real& other) const
427  {
429  derived().value() * other,
430  derived().derivatives() * other);
431  }
432 
434  operator*(const Real& other, const AutoDiffScalar<_DerType>& a)
435  {
436  return AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real,Scalar> >, DerType>::Type >(
437  a.value() * other,
438  a.derivatives() * other);
439  }
440 
441  inline AutoDiffScalar<_DerType>& operator*=(const Scalar& other)
442  {
443  *this = *this * other;
444  return derived();
445  }
446 };
447 
448 template<typename _DerType>
449 struct auto_diff_special_op<_DerType, false>
450 {
451  void operator*() const;
452  void operator-() const;
453  void operator+() const;
454 };
455 
456 template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols, typename B>
457 struct make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>, B> {
459  static void run(A& a, B& b) {
460  if((A_Rows==Dynamic || A_Cols==Dynamic) && (a.size()==0))
461  {
462  a.resize(b.size());
463  a.setZero();
464  }
465  }
466 };
467 
468 template<typename A, typename B_Scalar, int B_Rows, int B_Cols, int B_Options, int B_MaxRows, int B_MaxCols>
469 struct make_coherent_impl<A, Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > {
471  static void run(A& a, B& b) {
472  if((B_Rows==Dynamic || B_Cols==Dynamic) && (b.size()==0))
473  {
474  b.resize(a.size());
475  b.setZero();
476  }
477  }
478 };
479 
480 template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols,
481  typename B_Scalar, int B_Rows, int B_Cols, int B_Options, int B_MaxRows, int B_MaxCols>
482 struct make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>,
483  Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > {
486  static void run(A& a, B& b) {
487  if((A_Rows==Dynamic || A_Cols==Dynamic) && (a.size()==0))
488  {
489  a.resize(b.size());
490  a.setZero();
491  }
492  else if((B_Rows==Dynamic || B_Cols==Dynamic) && (b.size()==0))
493  {
494  b.resize(a.size());
495  b.setZero();
496  }
497  }
498 };
499 
500 } // end namespace internal
501 
502 template<typename DerType, typename BinOp>
503 struct ScalarBinaryOpTraits<AutoDiffScalar<DerType>,typename DerType::Scalar,BinOp>
504 {
506 };
507 
508 template<typename DerType, typename BinOp>
509 struct ScalarBinaryOpTraits<typename DerType::Scalar,AutoDiffScalar<DerType>, BinOp>
510 {
512 };
513 
514 
515 // The following is an attempt to let Eigen's known about expression template, but that's more tricky!
516 
517 // template<typename DerType, typename BinOp>
518 // struct ScalarBinaryOpTraits<AutoDiffScalar<DerType>,AutoDiffScalar<DerType>, BinOp>
519 // {
520 // enum { Defined = 1 };
521 // typedef AutoDiffScalar<typename DerType::PlainObject> ReturnType;
522 // };
523 //
524 // template<typename DerType1,typename DerType2, typename BinOp>
525 // struct ScalarBinaryOpTraits<AutoDiffScalar<DerType1>,AutoDiffScalar<DerType2>, BinOp>
526 // {
527 // enum { Defined = 1 };//internal::is_same<typename DerType1::Scalar,typename DerType2::Scalar>::value };
528 // typedef AutoDiffScalar<typename DerType1::PlainObject> ReturnType;
529 // };
530 
531 #define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \
532  template<typename DerType> \
533  inline const Eigen::AutoDiffScalar< \
534  EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(typename Eigen::internal::remove_all<DerType>::type, typename Eigen::internal::traits<typename Eigen::internal::remove_all<DerType>::type>::Scalar, product) > \
535  FUNC(const Eigen::AutoDiffScalar<DerType>& x) { \
536  using namespace Eigen; \
537  typedef typename Eigen::internal::traits<typename Eigen::internal::remove_all<DerType>::type>::Scalar Scalar; \
538  EIGEN_UNUSED_VARIABLE(sizeof(Scalar)); \
539  CODE; \
540  }
541 
542 template<typename DerType>
543 inline const AutoDiffScalar<DerType>& conj(const AutoDiffScalar<DerType>& x) { return x; }
544 template<typename DerType>
545 inline const AutoDiffScalar<DerType>& real(const AutoDiffScalar<DerType>& x) { return x; }
546 template<typename DerType>
547 inline typename DerType::Scalar imag(const AutoDiffScalar<DerType>&) { return 0.; }
548 template<typename DerType, typename T>
551  return (x <= y ? ADS(x) : ADS(y));
552 }
553 template<typename DerType, typename T>
556  return (x >= y ? ADS(x) : ADS(y));
557 }
558 template<typename DerType, typename T>
561  return (x < y ? ADS(x) : ADS(y));
562 }
563 template<typename DerType, typename T>
566  return (x > y ? ADS(x) : ADS(y));
567 }
568 template<typename DerType>
570  return (x.value() < y.value() ? x : y);
571 }
572 template<typename DerType>
574  return (x.value() >= y.value() ? x : y);
575 }
576 
577 
579  using std::abs;
580  return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives() * (x.value()<0 ? -1 : 1) );)
581 
583  using numext::abs2;
584  return Eigen::MakeAutoDiffScalar(abs2(x.value()), x.derivatives() * (Scalar(2)*x.value()));)
585 
587  using std::sqrt;
588  Scalar sqrtx = sqrt(x.value());
589  return Eigen::MakeAutoDiffScalar(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx));)
590 
592  using std::cos;
593  using std::sin;
594  return Eigen::MakeAutoDiffScalar(cos(x.value()), x.derivatives() * (-sin(x.value())));)
595 
597  using std::sin;
598  using std::cos;
599  return Eigen::MakeAutoDiffScalar(sin(x.value()),x.derivatives() * cos(x.value()));)
600 
602  using std::exp;
604  return Eigen::MakeAutoDiffScalar(expx,x.derivatives() * expx);)
605 
607  using std::log;
608  return Eigen::MakeAutoDiffScalar(log(x.value()),x.derivatives() * (Scalar(1)/x.value()));)
609 
610 template<typename DerType>
611 inline const Eigen::AutoDiffScalar<
614 {
615  using namespace Eigen;
616  using std::pow;
617  return Eigen::MakeAutoDiffScalar(pow(x.value(),y), x.derivatives() * (y * pow(x.value(),y-1)));
618 }
619 
620 
621 template<typename DerTypeA,typename DerTypeB>
624 {
625  using std::atan2;
627  typedef AutoDiffScalar<Matrix<Scalar,Dynamic,1> > PlainADS;
628  PlainADS ret;
629  ret.value() = atan2(a.value(), b.value());
630 
631  Scalar squared_hypot = a.value() * a.value() + b.value() * b.value();
632 
633  // if (squared_hypot==0) the derivation is undefined and the following results in a NaN:
634  ret.derivatives() = (a.derivatives() * b.value() - a.value() * b.derivatives()) / squared_hypot;
635 
636  return ret;
637 }
638 
640  using std::tan;
641  using std::cos;
643 
645  using std::sqrt;
646  using std::asin;
647  return Eigen::MakeAutoDiffScalar(asin(x.value()),x.derivatives() * (Scalar(1)/sqrt(1-numext::abs2(x.value()))));)
648 
650  using std::sqrt;
651  using std::acos;
652  return Eigen::MakeAutoDiffScalar(acos(x.value()),x.derivatives() * (Scalar(-1)/sqrt(1-numext::abs2(x.value()))));)
653 
655  using std::cosh;
656  using std::tanh;
658 
660  using std::sinh;
661  using std::cosh;
662  return Eigen::MakeAutoDiffScalar(sinh(x.value()),x.derivatives() * cosh(x.value()));)
663 
665  using std::sinh;
666  using std::cosh;
667  return Eigen::MakeAutoDiffScalar(cosh(x.value()),x.derivatives() * sinh(x.value()));)
668 
670 
671 template<typename DerType> struct NumTraits<AutoDiffScalar<DerType> >
673 {
675  typedef AutoDiffScalar<Matrix<typename NumTraits<typename DerTypeCleaned::Scalar>::Real,DerTypeCleaned::RowsAtCompileTime,DerTypeCleaned::ColsAtCompileTime,
676  0, DerTypeCleaned::MaxRowsAtCompileTime, DerTypeCleaned::MaxColsAtCompileTime> > Real;
680  enum{
681  RequireInitialization = 1
682  };
683 };
684 
685 }
686 
687 namespace std {
688 template <typename T>
689 class numeric_limits<Eigen::AutoDiffScalar<T> >
690  : public numeric_limits<typename T::Scalar> {};
691 
692 } // namespace std
693 
694 #endif // EIGEN_AUTODIFF_SCALAR_H
bool operator==(const Scalar &other) const
AutoDiffScalar(const Scalar &value, int nbDer, int derNumber)
SCALAR Scalar
Definition: bench_gemm.cpp:33
friend const AutoDiffScalar< CwiseUnaryOp< internal::scalar_opposite_op< Scalar >, const DerType > > operator-(const Scalar &a, const AutoDiffScalar &b)
#define max(a, b)
Definition: datatypes.h:20
AutoDiffScalar & operator*=(const AutoDiffScalar< OtherDerType > &other)
EIGEN_DEVICE_FUNC Derived & setZero(Index size)
const AutoDiffScalar< DerType > & conj(const AutoDiffScalar< DerType > &x)
internal::remove_all< _DerType >::type DerType
internal::auto_diff_special_op< _DerType,!internal::is_same< typename internal::traits< typename internal::remove_all< _DerType >::type >::Scalar, typename NumTraits< typename internal::traits< typename internal::remove_all< _DerType >::type >::Scalar >::Real >::value > Base
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_t > operator-(const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs, using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives()*(x.value()< 0?-1:1));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2
const AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType, Scalar, product) > operator*(const Scalar &other) const
Scalar * b
Definition: benchVecAdd.cpp:17
friend const AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType, Scalar, product) > operator*(const Scalar &other, const AutoDiffScalar &a)
A scalar type replacement with automatic differentation capability.
Scalar expx
EIGEN_DEVICE_FUNC const ExpReturnType exp() const
std::ostream & operator<<(std::ostream &s, const Packet16uc &v)
#define min(a, b)
Definition: datatypes.h:19
AutoDiffScalar & operator+=(const AutoDiffScalar< OtherDerType > &other)
void make_coherent(const A &a, const B &b)
EIGEN_DEVICE_FUNC const TanhReturnType tanh() const
EIGEN_DEVICE_FUNC const LogReturnType log() const
AutoDiffScalar(const AutoDiffScalar< OtherDerType > &other, typename internal::enable_if< internal::is_same< Scalar, typename internal::traits< typename internal::remove_all< OtherDerType >::type >::Scalar >::value &&internal::is_convertible< OtherDerType, DerType >::value, void * >::type=0)
EIGEN_DEVICE_FUNC const SqrtReturnType sqrt() const
EIGEN_DEVICE_FUNC const CoshReturnType cosh() const
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
DerType::Scalar imag(const AutoDiffScalar< DerType > &)
const AutoDiffScalar< typename CwiseUnaryOp< bind2nd_op< scalar_product_op< Scalar, Real > >, DerType >::Type > operator*(const Real &other) const
Definition: Half.h:150
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>(const half &a, const half &b)
Definition: Half.h:313
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
AutoDiffScalar< _DerType > & operator+=(const Real &other)
const AutoDiffScalar< DerType & > operator+(const Real &other) const
const AutoDiffScalar< CwiseBinaryOp< internal::scalar_difference_op< Scalar >, const DerType, const typename internal::remove_all< OtherDerType >::type > > operator-(const AutoDiffScalar< OtherDerType > &other) const
#define EIGEN_COMMA
Definition: Macros.h:481
AutoDiffScalar & operator-=(const AutoDiffScalar< OtherDerType > &other)
friend bool operator!=(const Scalar &a, const AutoDiffScalar &b)
const AutoDiffScalar< DerType & > operator+(const Scalar &other) const
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator<(const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
const AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(CwiseBinaryOp< internal::scalar_difference_op< Scalar > EIGEN_COMMA const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType, Scalar, product) EIGEN_COMMA const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(typename internal::remove_all< OtherDerType >::type, Scalar, product) >, Scalar, product) > operator/(const AutoDiffScalar< OtherDerType > &other) const
Array33i a
EIGEN_DEVICE_FUNC const CosReturnType cos() const
friend const AutoDiffScalar< DerType & > operator+(const Real &a, const AutoDiffScalar< _DerType > &b)
Generic expression where a coefficient-wise binary operator is applied to two expressions.
Definition: CwiseBinaryOp.h:77
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
AutoDiffScalar & operator/=(const Scalar &other)
NumTraits< Scalar >::Real Real
AutoDiffScalar & operator=(const AutoDiffScalar &other)
const AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType, Scalar, product) > operator/(const Scalar &other) const
EIGEN_DEVICE_FUNC const SinhReturnType sinh() const
const AutoDiffScalar< DerType & > operator-(const Scalar &b) const
bool operator<=(const Scalar &other) const
internal::traits< DerType >::Scalar Scalar
AutoDiffScalar(const Real &value)
RealScalar s
AutoDiffScalar< _DerType > & operator*=(const Scalar &other)
bool operator!=(const AutoDiffScalar< OtherDerType > &b) const
EIGEN_DEVICE_FUNC const TanReturnType tan() const
friend bool operator<=(const Scalar &a, const AutoDiffScalar &b)
AutoDiffScalar< NewDerType > MakeAutoDiffScalar(const typename NewDerType::Scalar &value, const NewDerType &der)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128< uint64_t, uint64_t > operator*(const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
AutoDiffScalar & operator=(const Scalar &other)
AutoDiffScalar< Matrix< typename NumTraits< typename DerTypeCleaned::Scalar >::Real, DerTypeCleaned::RowsAtCompileTime, DerTypeCleaned::ColsAtCompileTime, 0, DerTypeCleaned::MaxRowsAtCompileTime, DerTypeCleaned::MaxColsAtCompileTime > > Real
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Abs2ReturnType abs2() const
const AutoDiffScalar< _DerType > & derived() const
friend const AutoDiffScalar< DerType & > operator+(const Scalar &a, const AutoDiffScalar &b)
const AutoDiffScalar< CwiseUnaryOp< internal::scalar_opposite_op< Scalar >, const DerType > > operator-() const
EIGEN_DEVICE_FUNC const AcosReturnType acos() const
bool operator>=(const Scalar &other) const
friend const AutoDiffScalar< typename CwiseUnaryOp< bind1st_op< scalar_product_op< Real, Scalar > >, DerType >::Type > operator*(const Real &other, const AutoDiffScalar< _DerType > &a)
AutoDiffScalar & operator=(const AutoDiffScalar< OtherDerType > &other)
friend bool operator==(const Scalar &a, const AutoDiffScalar &b)
DenseIndex ret
Definition: level1_impl.h:59
const DerType & derivatives() const
const AutoDiffScalar< CwiseBinaryOp< internal::scalar_sum_op< Scalar >, const DerType, const typename internal::remove_all< OtherDerType >::type > > operator+(const AutoDiffScalar< OtherDerType > &other) const
bool operator>=(const AutoDiffScalar< OtherDerType > &b) const
const AutoDiffScalar< Matrix< typename internal::traits< typename internal::remove_all< DerTypeA >::type >::Scalar, Dynamic, 1 > > atan2(const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_t > operator+(const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
AutoDiffScalar & operator-=(const Scalar &other)
const Scalar & value() const
Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...
Definition: XprHelper.h:766
internal::remove_all< DerType >::type DerTypeCleaned
NumTraits< typename DerTypeCleaned::Scalar >::Literal Literal
bool operator==(const AutoDiffScalar< OtherDerType > &b) const
EIGEN_DEVICE_FUNC const SinReturnType sin() const
const int Dynamic
Definition: Constants.h:21
AutoDiffScalar(const Scalar &value, const DerType &der)
Jet< T, N > pow(const Jet< T, N > &f, double g)
Definition: jet.h:570
const AutoDiffScalar< CwiseBinaryOp< internal::scalar_sum_op< Scalar >, const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType, Scalar, product), const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(typename internal::remove_all< OtherDerType >::type, Scalar, product) > > operator*(const AutoDiffScalar< OtherDerType > &other) const
AutoDiffScalar & operator+=(const Scalar &other)
const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, typename Derived::Scalar, pow) pow(const Eigen
The matrix class, also used for vectors and row-vectors.
AutoDiffScalar(const AutoDiffScalar &other)
bool operator!=(const Scalar &other) const
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
const AutoDiffScalar< DerType > & real(const AutoDiffScalar< DerType > &x)
AutoDiffScalar & operator/=(const AutoDiffScalar< OtherDerType > &other)
#define abs(x)
Definition: datatypes.h:17
friend const AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DerType, Scalar, product) > operator/(const Scalar &other, const AutoDiffScalar &a)
friend bool operator>=(const Scalar &a, const AutoDiffScalar &b)
AutoDiffScalar & operator*=(const Scalar &other)
EIGEN_DEVICE_FUNC const AsinReturnType asin() const
Definition: pytypes.h:897
void product(const MatrixType &m)
Definition: product.h:20


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:41:40