GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-06-04 18:54:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

_DerType -> DerivativeType as underscore-followed-by-caps is a reserved identifier

Browse Source
This commit is contained in:
Alexander Karatarakis 2021-07-29 18:02:04 +00:00 committed by Antonio Sánchez
parent 5b81764c0f
commit f357283d31
1 changed files with 25 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
View File

@ -26,11 +26,11 @@ void make_coherent(const A& a, const B&b)
make_coherent_impl<A,B>::run(a.const_cast_derived(), b.const_cast_derived()); make_coherent_impl<A,B>::run(a.const_cast_derived(), b.const_cast_derived());
} }
template<typename _DerType, bool Enable> struct auto_diff_special_op; template<typename DerivativeType, bool Enable> struct auto_diff_special_op;
} // end namespace internal } // end namespace internal
template<typename _DerType> class AutoDiffScalar; template<typename DerivativeType> class AutoDiffScalar;
template<typename NewDerType> template<typename NewDerType>
inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::Scalar& value, const NewDerType &der) { inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::Scalar& value, const NewDerType &der) {
@ -38,16 +38,16 @@ inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::
} }
/** \class AutoDiffScalar /** \class AutoDiffScalar
* \brief A scalar type replacement with automatic differentation capability * \brief A scalar type replacement with automatic differentiation capability
* *
* \param _DerType the vector type used to store/represent the derivatives. The base scalar type * \param DerivativeType the vector type used to store/represent the derivatives. The base scalar type
* as well as the number of derivatives to compute are determined from this type. * as well as the number of derivatives to compute are determined from this type.
* Typical choices include, e.g., \c Vector4f for 4 derivatives, or \c VectorXf * Typical choices include, e.g., \c Vector4f for 4 derivatives, or \c VectorXf
* if the number of derivatives is not known at compile time, and/or, the number * if the number of derivatives is not known at compile time, and/or, the number
* of derivatives is large. * of derivatives is large.
* Note that _DerType can also be a reference (e.g., \c VectorXf&) to wrap a * Note that DerivativeType can also be a reference (e.g., \c VectorXf&) to wrap a
* existing vector into an AutoDiffScalar. * existing vector into an AutoDiffScalar.
* Finally, _DerType can also be any Eigen compatible expression. * Finally, DerivativeType can also be any Eigen compatible expression.
* *
* This class represents a scalar value while tracking its respective derivatives using Eigen's expression * This class represents a scalar value while tracking its respective derivatives using Eigen's expression
* template mechanism. * template mechanism.
@ -63,17 +63,17 @@ inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::
* *
*/ */
template<typename _DerType> template<typename DerivativeType>
class AutoDiffScalar class AutoDiffScalar
: public internal::auto_diff_special_op : public internal::auto_diff_special_op
<_DerType, !internal::is_same<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar, <DerivativeType, !internal::is_same<typename internal::traits<typename internal::remove_all<DerivativeType>::type>::Scalar,
typename NumTraits<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar>::Real>::value> typename NumTraits<typename internal::traits<typename internal::remove_all<DerivativeType>::type>::Scalar>::Real>::value>
{ {
public: public:
typedef internal::auto_diff_special_op typedef internal::auto_diff_special_op
<_DerType, !internal::is_same<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar, <DerivativeType, !internal::is_same<typename internal::traits<typename internal::remove_all<DerivativeType>::type>::Scalar,
typename NumTraits<typename internal::traits<typename internal::remove_all<_DerType>::type>::Scalar>::Real>::value> Base; typename NumTraits<typename internal::traits<typename internal::remove_all<DerivativeType>::type>::Scalar>::Real>::value> Base;
typedef typename internal::remove_all<_DerType>::type DerType; typedef typename internal::remove_all<DerivativeType>::type DerType;
typedef typename internal::traits<DerType>::Scalar Scalar; typedef typename internal::traits<DerType>::Scalar Scalar;
typedef typename NumTraits<Scalar>::Real Real; typedef typename NumTraits<Scalar>::Real Real;
@ -382,16 +382,16 @@ class AutoDiffScalar
namespace internal { namespace internal {
template<typename _DerType> template<typename DerivativeType>
struct auto_diff_special_op<_DerType, true> struct auto_diff_special_op<DerivativeType, true>
// : auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real, // : auto_diff_scalar_op<DerivativeType, typename NumTraits<Scalar>::Real,
// is_same<Scalar,typename NumTraits<Scalar>::Real>::value> // is_same<Scalar,typename NumTraits<Scalar>::Real>::value>
{ {
typedef typename remove_all<_DerType>::type DerType; typedef typename remove_all<DerivativeType>::type DerType;
typedef typename traits<DerType>::Scalar Scalar; typedef typename traits<DerType>::Scalar Scalar;
typedef typename NumTraits<Scalar>::Real Real; typedef typename NumTraits<Scalar>::Real Real;
// typedef auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real, // typedef auto_diff_scalar_op<DerivativeType, typename NumTraits<Scalar>::Real,
// is_same<Scalar,typename NumTraits<Scalar>::Real>::value> Base; // is_same<Scalar,typename NumTraits<Scalar>::Real>::value> Base;
// using Base::operator+; // using Base::operator+;
@ -401,8 +401,8 @@ struct auto_diff_special_op<_DerType, true>
// using Base::operator*; // using Base::operator*;
// using Base::operator*=; // using Base::operator*=;
const AutoDiffScalar<_DerType>& derived() const { return *static_cast<const AutoDiffScalar<_DerType>*>(this); } const AutoDiffScalar<DerivativeType>& derived() const { return *static_cast<const AutoDiffScalar<DerivativeType>*>(this); }
AutoDiffScalar<_DerType>& derived() { return *static_cast<AutoDiffScalar<_DerType>*>(this); } AutoDiffScalar<DerivativeType>& derived() { return *static_cast<AutoDiffScalar<DerivativeType>*>(this); }
inline const AutoDiffScalar<DerType&> operator+(const Real& other) const inline const AutoDiffScalar<DerType&> operator+(const Real& other) const
@ -410,12 +410,12 @@ struct auto_diff_special_op<_DerType, true>
return AutoDiffScalar<DerType&>(derived().value() + other, derived().derivatives()); return AutoDiffScalar<DerType&>(derived().value() + other, derived().derivatives());
} }
friend inline const AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar<_DerType>& b) friend inline const AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar<DerivativeType>& b)
{ {
return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives()); return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
} }
inline AutoDiffScalar<_DerType>& operator+=(const Real& other) inline AutoDiffScalar<DerivativeType>& operator+=(const Real& other)
{ {
derived().value() += other; derived().value() += other;
return derived(); return derived();
@ -431,22 +431,22 @@ struct auto_diff_special_op<_DerType, true>
} }
friend inline const AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real,Scalar> >, DerType>::Type > friend inline const AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real,Scalar> >, DerType>::Type >
operator*(const Real& other, const AutoDiffScalar<_DerType>& a) operator*(const Real& other, const AutoDiffScalar<DerivativeType>& a)
{ {
return AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real,Scalar> >, DerType>::Type >( return AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real,Scalar> >, DerType>::Type >(
a.value() * other, a.value() * other,
a.derivatives() * other); a.derivatives() * other);
} }
inline AutoDiffScalar<_DerType>& operator*=(const Scalar& other) inline AutoDiffScalar<DerivativeType>& operator*=(const Scalar& other)
{ {
*this = *this * other; *this = *this * other;
return derived(); return derived();
} }
}; };
template<typename _DerType> template<typename DerivativeType>
struct auto_diff_special_op<_DerType, false> struct auto_diff_special_op<DerivativeType, false>
{ {
void operator*() const; void operator*() const;
void operator-() const; void operator-() const;