@smake/eigen 1.0.2 → 1.1.1

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

@@ -10,59 +10,57 @@
 #ifndef EIGEN_TRANSLATION_H
 #define EIGEN_TRANSLATION_H
 
-namespace Eigen { 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
 
 /** \geometry_module \ingroup Geometry_Module
-  *
-  * \class Translation
-  *
-  * \brief Represents a translation transformation
-  *
-  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
-  * \tparam _Dim the  dimension of the space, can be a compile time value or Dynamic
-  *
-  * \note This class is not aimed to be used to store a translation transformation,
-  * but rather to make easier the constructions and updates of Transform objects.
-  *
-  * \sa class Scaling, class Transform
-  */
-template<typename _Scalar, int _Dim>
-class Translation
-{
-public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
+ *
+ * \class Translation
+ *
+ * \brief Represents a translation transformation
+ *
+ * \tparam Scalar_ the scalar type, i.e., the type of the coefficients.
+ * \tparam Dim_ the  dimension of the space, can be a compile time value or Dynamic
+ *
+ * \note This class is not aimed to be used to store a translation transformation,
+ * but rather to make easier the constructions and updates of Transform objects.
+ *
+ * \sa class Scaling, class Transform
+ */
+template <typename Scalar_, int Dim_>
+class Translation {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Dim_)
   /** dimension of the space */
-  enum { Dim = _Dim };
+  enum { Dim = Dim_ };
   /** the scalar type of the coefficients */
-  typedef _Scalar Scalar;
+  typedef Scalar_ Scalar;
   /** corresponding vector type */
-  typedef Matrix<Scalar,Dim,1> VectorType;
+  typedef Matrix<Scalar, Dim, 1> VectorType;
   /** corresponding linear transformation matrix type */
-  typedef Matrix<Scalar,Dim,Dim> LinearMatrixType;
+  typedef Matrix<Scalar, Dim, Dim> LinearMatrixType;
   /** corresponding affine transformation type */
-  typedef Transform<Scalar,Dim,Affine> AffineTransformType;
+  typedef Transform<Scalar, Dim, Affine> AffineTransformType;
   /** corresponding isometric transformation type */
-  typedef Transform<Scalar,Dim,Isometry> IsometryTransformType;
-
-protected:
+  typedef Transform<Scalar, Dim, Isometry> IsometryTransformType;
 
+ protected:
   VectorType m_coeffs;
 
-public:
-
+ public:
   /** Default constructor without initialization. */
   EIGEN_DEVICE_FUNC Translation() {}
   /**  */
-  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy)
-  {
-    eigen_assert(Dim==2);
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy) {
+    eigen_assert(Dim == 2);
     m_coeffs.x() = sx;
     m_coeffs.y() = sy;
   }
   /**  */
-  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz)
-  {
-    eigen_assert(Dim==3);
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz) {
+    eigen_assert(Dim == 3);
     m_coeffs.x() = sx;
     m_coeffs.y() = sy;
     m_coeffs.z() = sz;
@@ -70,19 +68,19 @@ public:
   /** Constructs and initialize the translation transformation from a vector of translation coefficients */
   EIGEN_DEVICE_FUNC explicit inline Translation(const VectorType& vector) : m_coeffs(vector) {}
 
-  /** \brief Retruns the x-translation by value. **/
-  EIGEN_DEVICE_FUNC inline Scalar x() const { return m_coeffs.x(); }
-  /** \brief Retruns the y-translation by value. **/
-  EIGEN_DEVICE_FUNC inline Scalar y() const { return m_coeffs.y(); }
-  /** \brief Retruns the z-translation by value. **/
-  EIGEN_DEVICE_FUNC inline Scalar z() const { return m_coeffs.z(); }
+  /** \brief Returns the x-translation by value. **/
+  EIGEN_DEVICE_FUNC constexpr Scalar x() const { return m_coeffs.x(); }
+  /** \brief Returns the y-translation by value. **/
+  EIGEN_DEVICE_FUNC constexpr Scalar y() const { return m_coeffs.y(); }
+  /** \brief Returns the z-translation by value. **/
+  EIGEN_DEVICE_FUNC constexpr Scalar z() const { return m_coeffs.z(); }
 
-  /** \brief Retruns the x-translation as a reference. **/
-  EIGEN_DEVICE_FUNC inline Scalar& x() { return m_coeffs.x(); }
-  /** \brief Retruns the y-translation as a reference. **/
-  EIGEN_DEVICE_FUNC inline Scalar& y() { return m_coeffs.y(); }
-  /** \brief Retruns the z-translation as a reference. **/
-  EIGEN_DEVICE_FUNC inline Scalar& z() { return m_coeffs.z(); }
+  /** \brief Returns the x-translation as a reference. **/
+  EIGEN_DEVICE_FUNC constexpr Scalar& x() { return m_coeffs.x(); }
+  /** \brief Returns the y-translation as a reference. **/
+  EIGEN_DEVICE_FUNC constexpr Scalar& y() { return m_coeffs.y(); }
+  /** \brief Returns the z-translation as a reference. **/
+  EIGEN_DEVICE_FUNC constexpr Scalar& z() { return m_coeffs.z(); }
 
   EIGEN_DEVICE_FUNC const VectorType& vector() const { return m_coeffs; }
   EIGEN_DEVICE_FUNC VectorType& vector() { return m_coeffs; }
@@ -91,49 +89,51 @@ public:
   EIGEN_DEVICE_FUNC VectorType& translation() { return m_coeffs; }
 
   /** Concatenates two translation */
-  EIGEN_DEVICE_FUNC inline Translation operator* (const Translation& other) const
-  { return Translation(m_coeffs + other.m_coeffs); }
+  EIGEN_DEVICE_FUNC inline Translation operator*(const Translation& other) const {
+    return Translation(m_coeffs + other.m_coeffs);
+  }
 
   /** Concatenates a translation and a uniform scaling */
-  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const UniformScaling<Scalar>& other) const;
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const UniformScaling<Scalar>& other) const;
 
   /** Concatenates a translation and a linear transformation */
-  template<typename OtherDerived>
-  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const EigenBase<OtherDerived>& linear) const;
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear) const;
 
   /** Concatenates a translation and a rotation */
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC inline IsometryTransformType operator*(const RotationBase<Derived,Dim>& r) const
-  { return *this * IsometryTransformType(r); }
+  template <typename Derived>
+  EIGEN_DEVICE_FUNC inline IsometryTransformType operator*(const RotationBase<Derived, Dim>& r) const {
+    return *this * IsometryTransformType(r);
+  }
 
   /** \returns the concatenation of a linear transformation \a l with the translation \a t */
   // its a nightmare to define a templated friend function outside its declaration
-  template<typename OtherDerived> friend
-  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear, const Translation& t)
-  {
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear,
+                                                                const Translation& t) {
     AffineTransformType res;
     res.matrix().setZero();
     res.linear() = linear.derived();
     res.translation() = linear.derived() * t.m_coeffs;
     res.matrix().row(Dim).setZero();
-    res(Dim,Dim) = Scalar(1);
+    res(Dim, Dim) = Scalar(1);
     return res;
   }
 
   /** Concatenates a translation and a transformation */
-  template<int Mode, int Options>
-  EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator* (const Transform<Scalar,Dim,Mode,Options>& t) const
-  {
-    Transform<Scalar,Dim,Mode> res = t;
+  template <int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline Transform<Scalar, Dim, Mode> operator*(
+      const Transform<Scalar, Dim, Mode, Options>& t) const {
+    Transform<Scalar, Dim, Mode> res = t;
     res.pretranslate(m_coeffs);
     return res;
   }
 
   /** Applies translation to vector */
-  template<typename Derived>
-  inline typename internal::enable_if<Derived::IsVectorAtCompileTime,VectorType>::type
-  operator* (const MatrixBase<Derived>& vec) const
-  { return m_coeffs + vec.derived(); }
+  template <typename Derived>
+  inline std::enable_if_t<Derived::IsVectorAtCompileTime, VectorType> operator*(const MatrixBase<Derived>& vec) const {
+    return m_coeffs + vec.derived();
+  }
 
   /** \returns the inverse translation (opposite) */
   Translation inverse() const { return Translation(-m_coeffs); }
@@ -141,62 +141,64 @@ public:
   static const Translation Identity() { return Translation(VectorType::Zero()); }
 
   /** \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<Translation,Translation<NewScalarType,Dim> >::type cast() const
-  { return typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::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<Translation, Translation<NewScalarType, Dim> >::type
+  cast() const {
+    return typename internal::cast_return_type<Translation, Translation<NewScalarType, Dim> >::type(*this);
+  }
 
   /** Copy constructor with scalar type conversion */
-  template<typename OtherScalarType>
-  EIGEN_DEVICE_FUNC inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
-  { m_coeffs = other.vector().template cast<Scalar>(); }
+  template <typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Translation(const Translation<OtherScalarType, Dim>& other) {
+    m_coeffs = other.vector().template cast<Scalar>();
+  }
 
   /** \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 Translation& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
-  { return m_coeffs.isApprox(other.m_coeffs, prec); }
-
+   * determined by \a prec.
+   *
+   * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename NumTraits<Scalar>::Real& prec =
+                                                                NumTraits<Scalar>::dummy_precision()) const {
+    return m_coeffs.isApprox(other.m_coeffs, prec);
+  }
 };
 
 /** \addtogroup Geometry_Module */
 //@{
 typedef Translation<float, 2> Translation2f;
-typedef Translation<double,2> Translation2d;
+typedef Translation<double, 2> Translation2d;
 typedef Translation<float, 3> Translation3f;
-typedef Translation<double,3> Translation3d;
+typedef Translation<double, 3> Translation3d;
 //@}
 
-template<typename Scalar, int Dim>
-EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
-Translation<Scalar,Dim>::operator* (const UniformScaling<Scalar>& other) const
-{
+template <typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar, Dim>::AffineTransformType Translation<Scalar, Dim>::operator*(
+    const UniformScaling<Scalar>& other) const {
   AffineTransformType res;
   res.matrix().setZero();
   res.linear().diagonal().fill(other.factor());
   res.translation() = m_coeffs;
-  res(Dim,Dim) = Scalar(1);
+  res(Dim, Dim) = Scalar(1);
   return res;
 }
 
-template<typename Scalar, int Dim>
-template<typename OtherDerived>
-EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
-Translation<Scalar,Dim>::operator* (const EigenBase<OtherDerived>& linear) const
-{
+template <typename Scalar, int Dim>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar, Dim>::AffineTransformType Translation<Scalar, Dim>::operator*(
+    const EigenBase<OtherDerived>& linear) const {
   AffineTransformType res;
   res.matrix().setZero();
   res.linear() = linear.derived();
   res.translation() = m_coeffs;
   res.matrix().row(Dim).setZero();
-  res(Dim,Dim) = Scalar(1);
+  res(Dim, Dim) = Scalar(1);
   return res;
 }
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_TRANSLATION_H
+#endif  // EIGEN_TRANSLATION_H

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

@@ -10,15 +10,16 @@
 #ifndef EIGEN_UMEYAMA_H
 #define EIGEN_UMEYAMA_H
 
-// This file requires the user to include 
+// This file requires the user to include
 // * Eigen/Core
-// * Eigen/LU 
+// * Eigen/LU
 // * Eigen/SVD
 // * Eigen/Array
 
-namespace Eigen { 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
 
-#ifndef EIGEN_PARSED_BY_DOXYGEN
+namespace Eigen {
 
 // These helpers are required since it allows to use mixed types as parameters
 // for the Umeyama. The problem with mixed parameters is that the return type
@@ -28,88 +29,83 @@ namespace internal {
 // Compile time return type deduction for different MatrixBase types.
 // Different means here different alignment and parameters but the same underlying
 // real scalar type.
-template<typename MatrixType, typename OtherMatrixType>
-struct umeyama_transform_matrix_type
-{
+template <typename MatrixType, typename OtherMatrixType>
+struct umeyama_transform_matrix_type {
   enum {
-    MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime),
+    MinRowsAtCompileTime =
+        internal::min_size_prefer_dynamic(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime),
 
     // When possible we want to choose some small fixed size value since the result
-    // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want.
-    HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1
+    // is likely to fit on the stack. So here, min_size_prefer_dynamic is not what we want.
+    HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime) + 1
   };
 
-  typedef Matrix<typename traits<MatrixType>::Scalar,
-    HomogeneousDimension,
-    HomogeneousDimension,
-    AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor),
-    HomogeneousDimension,
-    HomogeneousDimension
-  > type;
+  typedef Matrix<typename traits<MatrixType>::Scalar, HomogeneousDimension, HomogeneousDimension,
+                 AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor), HomogeneousDimension,
+                 HomogeneousDimension>
+      type;
 };
 
-}
-
-#endif
+}  // namespace internal
 
 /**
-* \geometry_module \ingroup Geometry_Module
-*
-* \brief Returns the transformation between two point sets.
-*
-* The algorithm is based on:
-* "Least-squares estimation of transformation parameters between two point patterns",
-* Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
-*
-* It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
-* \f{align*}
-*   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
-* \f}
-* is minimized.
-*
-* The algorithm is based on the analysis of the covariance matrix
-* \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
-* of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where 
-* \f$d\f$ is corresponding to the dimension (which is typically small).
-* The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
-* though the actual computational effort lies in the covariance
-* matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when 
-* the input point sets have dimension \f$d \times m\f$.
-*
-* Currently the method is working only for floating point matrices.
-*
-* \todo Should the return type of umeyama() become a Transform?
-*
-* \param src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$.
-* \param dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
-* \param with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed.
-* \return The homogeneous transformation 
-* \f{align*}
-*   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
-* \f}
-* minimizing the residual above. This transformation is always returned as an 
-* Eigen::Matrix.
-*/
+ * \geometry_module \ingroup Geometry_Module
+ *
+ * \brief Returns the transformation between two point sets.
+ *
+ * The algorithm is based on:
+ * "Least-squares estimation of transformation parameters between two point patterns",
+ * Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
+ *
+ * It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
+ * \f{align*}
+ *   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
+ * \f}
+ * is minimized.
+ *
+ * The algorithm is based on the analysis of the covariance matrix
+ * \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
+ * of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where
+ * \f$d\f$ is corresponding to the dimension (which is typically small).
+ * The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+ * though the actual computational effort lies in the covariance
+ * matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when
+ * the input point sets have dimension \f$d \times m\f$.
+ *
+ * Currently the method is working only for floating point matrices.
+ *
+ * \todo Should the return type of umeyama() become a Transform?
+ *
+ * \param src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$.
+ * \param dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
+ * \param with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed.
+ * \return The homogeneous transformation
+ * \f{align*}
+ *   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
+ * \f}
+ * minimizing the residual above. This transformation is always returned as an
+ * Eigen::Matrix.
+ */
 template <typename Derived, typename OtherDerived>
-typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
-umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true)
-{
+typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type umeyama(
+    const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true) {
   typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType;
   typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
 
   EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
-    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  EIGEN_STATIC_ASSERT(
+      (internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
-  enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
+  enum { Dimension = internal::min_size_prefer_dynamic(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
 
   typedef Matrix<Scalar, Dimension, 1> VectorType;
   typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
   typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType;
 
-  const Index m = src.rows(); // dimension
-  const Index n = src.cols(); // number of measurements
+  const Index m = src.rows();  // dimension
+  const Index n = src.cols();  // number of measurements
 
   // required for demeaning ...
   const RealScalar one_over_n = RealScalar(1) / static_cast<RealScalar>(n);
@@ -122,45 +118,44 @@ umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, boo
   const RowMajorMatrixType src_demean = src.colwise() - src_mean;
   const RowMajorMatrixType dst_demean = dst.colwise() - dst_mean;
 
-  // Eq. (36)-(37)
-  const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
-
   // Eq. (38)
   const MatrixType sigma = one_over_n * dst_demean * src_demean.transpose();
 
-  JacobiSVD<MatrixType> svd(sigma, ComputeFullU | ComputeFullV);
+  JacobiSVD<MatrixType, ComputeFullU | ComputeFullV> svd(sigma);
 
   // Initialize the resulting transformation with an identity matrix...
-  TransformationMatrixType Rt = TransformationMatrixType::Identity(m+1,m+1);
+  TransformationMatrixType Rt = TransformationMatrixType::Identity(m + 1, m + 1);
 
   // Eq. (39)
   VectorType S = VectorType::Ones(m);
 
-  if  ( svd.matrixU().determinant() * svd.matrixV().determinant() < 0 )
-    S(m-1) = -1;
+  if (svd.matrixU().determinant() * svd.matrixV().determinant() < 0) {
+    Index tmp = m - 1;
+    S(tmp) = -1;
+  }
 
   // Eq. (40) and (43)
-  Rt.block(0,0,m,m).noalias() = svd.matrixU() * S.asDiagonal() * svd.matrixV().transpose();
+  Rt.block(0, 0, m, m).noalias() = svd.matrixU() * S.asDiagonal() * svd.matrixV().transpose();
+
+  if (with_scaling) {
+    // Eq. (36)-(37)
+    const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
 
-  if (with_scaling)
-  {
     // Eq. (42)
-    const Scalar c = Scalar(1)/src_var * svd.singularValues().dot(S);
+    const Scalar c = Scalar(1) / src_var * svd.singularValues().dot(S);
 
     // Eq. (41)
     Rt.col(m).head(m) = dst_mean;
-    Rt.col(m).head(m).noalias() -= c*Rt.topLeftCorner(m,m)*src_mean;
-    Rt.block(0,0,m,m) *= c;
-  }
-  else
-  {
+    Rt.col(m).head(m).noalias() -= c * Rt.topLeftCorner(m, m) * src_mean;
+    Rt.block(0, 0, m, m) *= c;
+  } else {
     Rt.col(m).head(m) = dst_mean;
-    Rt.col(m).head(m).noalias() -= Rt.topLeftCorner(m,m)*src_mean;
+    Rt.col(m).head(m).noalias() -= Rt.topLeftCorner(m, m) * src_mean;
   }
 
   return Rt;
 }
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_UMEYAMA_H
+#endif  // EIGEN_UMEYAMA_H