@smake/eigen 1.0.2 → 1.1.1

package/eigen/Eigen/src/Geometry/Rotation2D.h

@@ -10,67 +10,65 @@
 #ifndef EIGEN_ROTATION2D_H
 #define EIGEN_ROTATION2D_H
 
-namespace Eigen { 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
 
 /** \geometry_module \ingroup Geometry_Module
-  *
-  * \class Rotation2D
-  *
-  * \brief Represents a rotation/orientation in a 2 dimensional space.
-  *
-  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
-  *
-  * This class is equivalent to a single scalar representing a counter clock wise rotation
-  * as a single angle in radian. It provides some additional features such as the automatic
-  * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar
-  * interface to Quaternion in order to facilitate the writing of generic algorithms
-  * dealing with rotations.
-  *
-  * \sa class Quaternion, class Transform
-  */
+ *
+ * \class Rotation2D
+ *
+ * \brief Represents a rotation/orientation in a 2 dimensional space.
+ *
+ * \tparam Scalar_ the scalar type, i.e., the type of the coefficients
+ *
+ * This class is equivalent to a single scalar representing a counter clock wise rotation
+ * as a single angle in radian. It provides some additional features such as the automatic
+ * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar
+ * interface to Quaternion in order to facilitate the writing of generic algorithms
+ * dealing with rotations.
+ *
+ * \sa class Quaternion, class Transform
+ */
 
 namespace internal {
 
-template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
-{
-  typedef _Scalar Scalar;
+template <typename Scalar_>
+struct traits<Rotation2D<Scalar_> > {
+  typedef Scalar_ Scalar;
 };
-} // end namespace internal
-
-template<typename _Scalar>
-class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
-{
-  typedef RotationBase<Rotation2D<_Scalar>,2> Base;
+}  // end namespace internal
 
-public:
+template <typename Scalar_>
+class Rotation2D : public RotationBase<Rotation2D<Scalar_>, 2> {
+  typedef RotationBase<Rotation2D<Scalar_>, 2> Base;
 
+ public:
   using Base::operator*;
 
   enum { Dim = 2 };
   /** the scalar type of the coefficients */
-  typedef _Scalar Scalar;
-  typedef Matrix<Scalar,2,1> Vector2;
-  typedef Matrix<Scalar,2,2> Matrix2;
-
-protected:
+  typedef Scalar_ Scalar;
+  typedef Matrix<Scalar, 2, 1> Vector2;
+  typedef Matrix<Scalar, 2, 2> Matrix2;
 
+ protected:
   Scalar m_angle;
 
-public:
-
+ public:
   /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
   EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {}
-  
-  /** Default constructor wihtout initialization. The represented rotation is undefined. */
+
+  /** Default constructor without initialization. The represented rotation is undefined. */
   EIGEN_DEVICE_FUNC Rotation2D() {}
 
   /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
-    *
-    * \sa fromRotationMatrix()
-    */
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m)
-  {
+   *
+   * \sa fromRotationMatrix()
+   */
+  template <typename Derived>
+  EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m) {
     fromRotationMatrix(m.derived());
   }
 
@@ -79,18 +77,20 @@ public:
 
   /** \returns a read-write reference to the rotation angle */
   EIGEN_DEVICE_FUNC inline Scalar& angle() { return m_angle; }
-  
+
   /** \returns the rotation angle in [0,2pi] */
   EIGEN_DEVICE_FUNC inline Scalar smallestPositiveAngle() const {
-    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
-    return tmp<Scalar(0) ? tmp + Scalar(2*EIGEN_PI) : tmp;
+    Scalar tmp = numext::fmod(m_angle, Scalar(2 * EIGEN_PI));
+    return tmp < Scalar(0) ? tmp + Scalar(2 * EIGEN_PI) : tmp;
   }
-  
+
   /** \returns the rotation angle in [-pi,pi] */
   EIGEN_DEVICE_FUNC inline Scalar smallestAngle() const {
-    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
-    if(tmp>Scalar(EIGEN_PI))       tmp -= Scalar(2*EIGEN_PI);
-    else if(tmp<-Scalar(EIGEN_PI)) tmp += Scalar(2*EIGEN_PI);
+    Scalar tmp = numext::fmod(m_angle, Scalar(2 * EIGEN_PI));
+    if (tmp > Scalar(EIGEN_PI))
+      tmp -= Scalar(2 * EIGEN_PI);
+    else if (tmp < -Scalar(EIGEN_PI))
+      tmp += Scalar(2 * EIGEN_PI);
     return tmp;
   }
 
@@ -98,102 +98,104 @@ public:
   EIGEN_DEVICE_FUNC inline Rotation2D inverse() const { return Rotation2D(-m_angle); }
 
   /** Concatenates two rotations */
-  EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const
-  { return Rotation2D(m_angle + other.m_angle); }
+  EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const {
+    return Rotation2D(m_angle + other.m_angle);
+  }
 
   /** Concatenates two rotations */
-  EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other)
-  { m_angle += other.m_angle; return *this; }
+  EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other) {
+    m_angle += other.m_angle;
+    return *this;
+  }
 
   /** Applies the rotation to a 2D vector */
-  EIGEN_DEVICE_FUNC Vector2 operator* (const Vector2& vec) const
-  { return toRotationMatrix() * vec; }
-  
-  template<typename Derived>
+  EIGEN_DEVICE_FUNC Vector2 operator*(const Vector2& vec) const { return toRotationMatrix() * vec; }
+
+  template <typename Derived>
   EIGEN_DEVICE_FUNC Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m);
   EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
 
   /** Set \c *this from a 2x2 rotation matrix \a mat.
-    * In other words, this function extract the rotation angle from the rotation matrix.
-    *
-    * This method is an alias for fromRotationMatrix()
-    *
-    * \sa fromRotationMatrix()
-    */
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC Rotation2D& operator=(const  MatrixBase<Derived>& m)
-  { return fromRotationMatrix(m.derived()); }
+   * In other words, this function extract the rotation angle from the rotation matrix.
+   *
+   * This method is an alias for fromRotationMatrix()
+   *
+   * \sa fromRotationMatrix()
+   */
+  template <typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& operator=(const MatrixBase<Derived>& m) {
+    return fromRotationMatrix(m.derived());
+  }
 
   /** \returns the spherical interpolation between \c *this and \a other using
-    * parameter \a t. It is in fact equivalent to a linear interpolation.
-    */
-  EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const
-  {
-    Scalar dist = Rotation2D(other.m_angle-m_angle).smallestAngle();
-    return Rotation2D(m_angle + dist*t);
+   * parameter \a t. It is in fact equivalent to a linear interpolation.
+   */
+  EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const {
+    Scalar dist = Rotation2D(other.m_angle - m_angle).smallestAngle();
+    return Rotation2D(m_angle + dist * t);
   }
 
   /** \returns \c *this with scalar type casted to \a NewScalarType
-    *
-    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
-    * then this function smartly returns a const reference to \c *this.
-    */
-  template<typename NewScalarType>
-  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const
-  { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); }
+   *
+   * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+   * then this function smartly returns a const reference to \c *this.
+   */
+  template <typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D, Rotation2D<NewScalarType> >::type cast()
+      const {
+    return typename internal::cast_return_type<Rotation2D, Rotation2D<NewScalarType> >::type(*this);
+  }
 
   /** Copy constructor with scalar type conversion */
-  template<typename OtherScalarType>
-  EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
-  {
+  template <typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other) {
     m_angle = Scalar(other.angle());
   }
 
   EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2D(0); }
 
   /** \returns \c true if \c *this is approximately equal to \a other, within the precision
-    * determined by \a prec.
-    *
-    * \sa MatrixBase::isApprox() */
-  EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
-  { return internal::isApprox(m_angle,other.m_angle, prec); }
-  
+   * determined by \a prec.
+   *
+   * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec =
+                                                               NumTraits<Scalar>::dummy_precision()) const {
+    return internal::isApprox(m_angle, other.m_angle, prec);
+  }
 };
 
 /** \ingroup Geometry_Module
-  * single precision 2D rotation type */
+ * single precision 2D rotation type */
 typedef Rotation2D<float> Rotation2Df;
 /** \ingroup Geometry_Module
-  * double precision 2D rotation type */
+ * double precision 2D rotation type */
 typedef Rotation2D<double> Rotation2Dd;
 
 /** Set \c *this from a 2x2 rotation matrix \a mat.
-  * In other words, this function extract the rotation angle
-  * from the rotation matrix.
-  */
-template<typename Scalar>
-template<typename Derived>
-EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
-{
-  EIGEN_USING_STD_MATH(atan2)
-  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
-  m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
+ * In other words, this function extract the rotation angle
+ * from the rotation matrix.
+ */
+template <typename Scalar>
+template <typename Derived>
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat) {
+  EIGEN_USING_STD(atan2)
+  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime == 2 && Derived::ColsAtCompileTime == 2,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
+  m_angle = atan2(mat.coeff(1, 0), mat.coeff(0, 0));
   return *this;
 }
 
 /** Constructs and \returns an equivalent 2x2 rotation matrix.
-  */
-template<typename Scalar>
-typename Rotation2D<Scalar>::Matrix2
-EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const
-{
-  EIGEN_USING_STD_MATH(sin)
-  EIGEN_USING_STD_MATH(cos)
+ */
+template <typename Scalar>
+typename Rotation2D<Scalar>::Matrix2 EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const {
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
   Scalar sinA = sin(m_angle);
   Scalar cosA = cos(m_angle);
   return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
 }
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_ROTATION2D_H
+#endif  // EIGEN_ROTATION2D_H

package/eigen/Eigen/src/Geometry/RotationBase.h

@@ -10,197 +10,200 @@
 #ifndef EIGEN_ROTATIONBASE_H
 #define EIGEN_ROTATIONBASE_H
 
-namespace Eigen { 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
 
 // forward declaration
 namespace internal {
-template<typename RotationDerived, typename MatrixType, bool IsVector=MatrixType::IsVectorAtCompileTime>
+template <typename RotationDerived, typename MatrixType, bool IsVector = MatrixType::IsVectorAtCompileTime>
 struct rotation_base_generic_product_selector;
 }
 
 /** \class RotationBase
-  *
-  * \brief Common base class for compact rotation representations
-  *
-  * \tparam Derived is the derived type, i.e., a rotation type
-  * \tparam _Dim the dimension of the space
-  */
-template<typename Derived, int _Dim>
-class RotationBase
-{
-  public:
-    enum { Dim = _Dim };
-    /** the scalar type of the coefficients */
-    typedef typename internal::traits<Derived>::Scalar Scalar;
-
-    /** corresponding linear transformation matrix type */
-    typedef Matrix<Scalar,Dim,Dim> RotationMatrixType;
-    typedef Matrix<Scalar,Dim,1> VectorType;
-
-  public:
-    EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
-    EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
-
-    /** \returns an equivalent rotation matrix */
-    EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
-
-    /** \returns an equivalent rotation matrix 
-      * This function is added to be conform with the Transform class' naming scheme.
-      */
-    EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
-
-    /** \returns the inverse rotation */
-    EIGEN_DEVICE_FUNC inline Derived inverse() const { return derived().inverse(); }
-
-    /** \returns the concatenation of the rotation \c *this with a translation \a t */
-    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Isometry> operator*(const Translation<Scalar,Dim>& t) const
-    { return Transform<Scalar,Dim,Isometry>(*this) * t; }
-
-    /** \returns the concatenation of the rotation \c *this with a uniform scaling \a s */
-    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const UniformScaling<Scalar>& s) const
-    { return toRotationMatrix() * s.factor(); }
-
-    /** \returns the concatenation of the rotation \c *this with a generic expression \a e
-      * \a e can be:
-      *  - a DimxDim linear transformation matrix
-      *  - a DimxDim diagonal matrix (axis aligned scaling)
-      *  - a vector of size Dim
-      */
-    template<typename OtherDerived>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType
-    operator*(const EigenBase<OtherDerived>& e) const
-    { return internal::rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); }
-
-    /** \returns the concatenation of a linear transformation \a l with the rotation \a r */
-    template<typename OtherDerived> friend
-    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r)
-    { return l.derived() * r.toRotationMatrix(); }
-
-    /** \returns the concatenation of a scaling \a l with the rotation \a r */
-    EIGEN_DEVICE_FUNC friend inline Transform<Scalar,Dim,Affine> operator*(const DiagonalMatrix<Scalar,Dim>& l, const Derived& r)
-    { 
-      Transform<Scalar,Dim,Affine> res(r);
-      res.linear().applyOnTheLeft(l);
-      return res;
-    }
-
-    /** \returns the concatenation of the rotation \c *this with a transformation \a t */
-    template<int Mode, int Options>
-    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator*(const Transform<Scalar,Dim,Mode,Options>& t) const
-    { return toRotationMatrix() * t; }
-
-    template<typename OtherVectorType>
-    EIGEN_DEVICE_FUNC inline VectorType _transformVector(const OtherVectorType& v) const
-    { return toRotationMatrix() * v; }
+ *
+ * \brief Common base class for compact rotation representations
+ *
+ * \tparam Derived is the derived type, i.e., a rotation type
+ * \tparam Dim_ the dimension of the space
+ */
+template <typename Derived, int Dim_>
+class RotationBase {
+ public:
+  enum { Dim = Dim_ };
+  /** the scalar type of the coefficients */
+  typedef typename internal::traits<Derived>::Scalar Scalar;
+
+  /** corresponding linear transformation matrix type */
+  typedef Matrix<Scalar, Dim, Dim> RotationMatrixType;
+  typedef Matrix<Scalar, Dim, 1> VectorType;
+
+ public:
+  EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+  EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+  /** \returns an equivalent rotation matrix */
+  EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
+
+  /** \returns an equivalent rotation matrix
+   * This function is added to be conform with the Transform class' naming scheme.
+   */
+  EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
+
+  /** \returns the inverse rotation */
+  EIGEN_DEVICE_FUNC inline Derived inverse() const { return derived().inverse(); }
+
+  /** \returns the concatenation of the rotation \c *this with a translation \a t */
+  EIGEN_DEVICE_FUNC inline Transform<Scalar, Dim, Isometry> operator*(const Translation<Scalar, Dim>& t) const {
+    return Transform<Scalar, Dim, Isometry>(*this) * t;
+  }
+
+  /** \returns the concatenation of the rotation \c *this with a uniform scaling \a s */
+  EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const UniformScaling<Scalar>& s) const {
+    return toRotationMatrix() * s.factor();
+  }
+
+  /** \returns the concatenation of the rotation \c *this with a generic expression \a e
+   * \a e can be:
+   *  - a DimxDim linear transformation matrix
+   *  - a DimxDim diagonal matrix (axis aligned scaling)
+   *  - a vector of size Dim
+   */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      typename internal::rotation_base_generic_product_selector<Derived, OtherDerived,
+                                                                OtherDerived::IsVectorAtCompileTime>::ReturnType
+      operator*(const EigenBase<OtherDerived>& e) const {
+    return internal::rotation_base_generic_product_selector<Derived, OtherDerived>::run(derived(), e.derived());
+  }
+
+  /** \returns the concatenation of a linear transformation \a l with the rotation \a r */
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r) {
+    return l.derived() * r.toRotationMatrix();
+  }
+
+  /** \returns the concatenation of a scaling \a l with the rotation \a r */
+  EIGEN_DEVICE_FUNC friend inline Transform<Scalar, Dim, Affine> operator*(const DiagonalMatrix<Scalar, Dim>& l,
+                                                                           const Derived& r) {
+    Transform<Scalar, Dim, Affine> res(r);
+    res.linear().applyOnTheLeft(l);
+    return res;
+  }
+
+  /** \returns the concatenation of the rotation \c *this with a transformation \a t */
+  template <int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline Transform<Scalar, Dim, Mode> operator*(
+      const Transform<Scalar, Dim, Mode, Options>& t) const {
+    return toRotationMatrix() * t;
+  }
+
+  template <typename OtherVectorType>
+  EIGEN_DEVICE_FUNC inline VectorType _transformVector(const OtherVectorType& v) const {
+    return toRotationMatrix() * v;
+  }
 };
 
 namespace internal {
 
 // implementation of the generic product rotation * matrix
-template<typename RotationDerived, typename MatrixType>
-struct rotation_base_generic_product_selector<RotationDerived,MatrixType,false>
-{
+template <typename RotationDerived, typename MatrixType>
+struct rotation_base_generic_product_selector<RotationDerived, MatrixType, false> {
   enum { Dim = RotationDerived::Dim };
-  typedef Matrix<typename RotationDerived::Scalar,Dim,Dim> ReturnType;
-  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m)
-  { return r.toRotationMatrix() * m; }
+  typedef Matrix<typename RotationDerived::Scalar, Dim, Dim> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m) {
+    return r.toRotationMatrix() * m;
+  }
 };
 
-template<typename RotationDerived, typename Scalar, int Dim, int MaxDim>
-struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false >
-{
-  typedef Transform<Scalar,Dim,Affine> ReturnType;
-  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m)
-  {
+template <typename RotationDerived, typename Scalar, int Dim, int MaxDim>
+struct rotation_base_generic_product_selector<RotationDerived, DiagonalMatrix<Scalar, Dim, MaxDim>, false> {
+  typedef Transform<Scalar, Dim, Affine> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r,
+                                                 const DiagonalMatrix<Scalar, Dim, MaxDim>& m) {
     ReturnType res(r);
     res.linear() *= m;
     return res;
   }
 };
 
-template<typename RotationDerived,typename OtherVectorType>
-struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true>
-{
+template <typename RotationDerived, typename OtherVectorType>
+struct rotation_base_generic_product_selector<RotationDerived, OtherVectorType, true> {
   enum { Dim = RotationDerived::Dim };
-  typedef Matrix<typename RotationDerived::Scalar,Dim,1> ReturnType;
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v)
-  {
+  typedef Matrix<typename RotationDerived::Scalar, Dim, 1> ReturnType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v) {
     return r._transformVector(v);
   }
 };
 
-} // end namespace internal
+}  // end namespace internal
 
 /** \geometry_module
-  *
-  * \brief Constructs a Dim x Dim rotation matrix from the rotation \a r
-  */
-template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
-template<typename OtherDerived>
-EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
-::Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
-{
-  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+ *
+ * \brief Constructs a Dim x Dim rotation matrix from the rotation \a r
+ */
+template <typename Scalar_, int Rows_, int Cols_, int Storage_, int MaxRows_, int MaxCols_>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<Scalar_, Rows_, Cols_, Storage_, MaxRows_, MaxCols_>::Matrix(
+    const RotationBase<OtherDerived, ColsAtCompileTime>& r) {
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix, int(OtherDerived::Dim), int(OtherDerived::Dim))
   *this = r.toRotationMatrix();
 }
 
 /** \geometry_module
-  *
-  * \brief Set a Dim x Dim rotation matrix from the rotation \a r
-  */
-template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
-template<typename OtherDerived>
-EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>&
-Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
-::operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
-{
-  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+ *
+ * \brief Set a Dim x Dim rotation matrix from the rotation \a r
+ */
+template <typename Scalar_, int Rows_, int Cols_, int Storage_, int MaxRows_, int MaxCols_>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<Scalar_, Rows_, Cols_, Storage_, MaxRows_, MaxCols_>&
+Matrix<Scalar_, Rows_, Cols_, Storage_, MaxRows_, MaxCols_>::operator=(
+    const RotationBase<OtherDerived, ColsAtCompileTime>& r) {
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix, int(OtherDerived::Dim), int(OtherDerived::Dim))
   return *this = r.toRotationMatrix();
 }
 
 namespace internal {
 
 /** \internal
-  *
-  * Helper function to return an arbitrary rotation object to a rotation matrix.
-  *
-  * \tparam Scalar the numeric type of the matrix coefficients
-  * \tparam Dim the dimension of the current space
-  *
-  * It returns a Dim x Dim fixed size matrix.
-  *
-  * Default specializations are provided for:
-  *   - any scalar type (2D),
-  *   - any matrix expression,
-  *   - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D)
-  *
-  * Currently toRotationMatrix is only used by Transform.
-  *
-  * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
-  */
-template<typename Scalar, int Dim>
-EIGEN_DEVICE_FUNC static inline Matrix<Scalar,2,2> toRotationMatrix(const Scalar& s)
-{
-  EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+ *
+ * Helper function to return an arbitrary rotation object to a rotation matrix.
+ *
+ * \tparam Scalar the numeric type of the matrix coefficients
+ * \tparam Dim the dimension of the current space
+ *
+ * It returns a Dim x Dim fixed size matrix.
+ *
+ * Default specializations are provided for:
+ *   - any scalar type (2D),
+ *   - any matrix expression,
+ *   - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D)
+ *
+ * Currently toRotationMatrix is only used by Transform.
+ *
+ * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
+ */
+template <typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar, 2, 2> toRotationMatrix(const Scalar& s) {
+  EIGEN_STATIC_ASSERT(Dim == 2, YOU_MADE_A_PROGRAMMING_MISTAKE)
   return Rotation2D<Scalar>(s).toRotationMatrix();
 }
 
-template<typename Scalar, int Dim, typename OtherDerived>
-EIGEN_DEVICE_FUNC static inline Matrix<Scalar,Dim,Dim> toRotationMatrix(const RotationBase<OtherDerived,Dim>& r)
-{
+template <typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar, Dim, Dim> toRotationMatrix(const RotationBase<OtherDerived, Dim>& r) {
   return r.toRotationMatrix();
 }
 
-template<typename Scalar, int Dim, typename OtherDerived>
-EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat)
-{
-  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim,
-    YOU_MADE_A_PROGRAMMING_MISTAKE)
+template <typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat) {
+  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime == Dim && OtherDerived::ColsAtCompileTime == Dim,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
   return mat;
 }
 
-} // end namespace internal
+}  // end namespace internal
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_ROTATIONBASE_H
+#endif  // EIGEN_ROTATIONBASE_H