@smake/eigen 1.1.0 → 1.1.1

package/eigen/Eigen/src/Core/CommaInitializer.h

@@ -11,49 +11,46 @@
 #ifndef EIGEN_COMMAINITIALIZER_H
 #define EIGEN_COMMAINITIALIZER_H
 
-namespace Eigen { 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
 
 /** \class CommaInitializer
-  * \ingroup Core_Module
-  *
-  * \brief Helper class used by the comma initializer operator
-  *
-  * This class is internally used to implement the comma initializer feature. It is
-  * the return type of MatrixBase::operator<<, and most of the time this is the only
-  * way it is used.
-  *
-  * \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
-  */
-template<typename XprType>
-struct CommaInitializer
-{
+ * \ingroup Core_Module
+ *
+ * \brief Helper class used by the comma initializer operator
+ *
+ * This class is internally used to implement the comma initializer feature. It is
+ * the return type of MatrixBase::operator<<, and most of the time this is the only
+ * way it is used.
+ *
+ * \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
+ */
+template <typename XprType>
+struct CommaInitializer {
   typedef typename XprType::Scalar Scalar;
 
-  EIGEN_DEVICE_FUNC
-  inline CommaInitializer(XprType& xpr, const Scalar& s)
-    : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1)
-  {
-    eigen_assert(m_xpr.rows() > 0 && m_xpr.cols() > 0
-      && "Cannot comma-initialize a 0x0 matrix (operator<<)");
-    m_xpr.coeffRef(0,0) = s;
+  EIGEN_DEVICE_FUNC inline CommaInitializer(XprType& xpr, const Scalar& s)
+      : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1) {
+    eigen_assert(m_xpr.rows() > 0 && m_xpr.cols() > 0 && "Cannot comma-initialize a 0x0 matrix (operator<<)");
+    m_xpr.coeffRef(0, 0) = s;
   }
 
-  template<typename OtherDerived>
-  EIGEN_DEVICE_FUNC
-  inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
-    : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
-  {
-    eigen_assert(m_xpr.rows() >= other.rows() && m_xpr.cols() >= other.cols()
-      && "Cannot comma-initialize a 0x0 matrix (operator<<)");
-    m_xpr.block(0, 0, other.rows(), other.cols()) = other;
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
+      : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows()) {
+    eigen_assert(m_xpr.rows() >= other.rows() && m_xpr.cols() >= other.cols() &&
+                 "Cannot comma-initialize a 0x0 matrix (operator<<)");
+    m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>(0, 0, other.rows(),
+                                                                                           other.cols()) = other;
   }
 
-  /* Copy/Move constructor which transfers ownership. This is crucial in 
+  /* Copy/Move constructor which transfers ownership. This is crucial in
    * absence of return value optimization to avoid assertions during destruction. */
   // FIXME in C++11 mode this could be replaced by a proper RValue constructor
-  EIGEN_DEVICE_FUNC
-  inline CommaInitializer(const CommaInitializer& o)
-  : m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) {
+  EIGEN_DEVICE_FUNC inline CommaInitializer(const CommaInitializer& o)
+      : m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) {
     // Mark original object as finished. In absence of R-value references we need to const_cast:
     const_cast<CommaInitializer&>(o).m_row = m_xpr.rows();
     const_cast<CommaInitializer&>(o).m_col = m_xpr.cols();
@@ -61,104 +58,92 @@ struct CommaInitializer
   }
 
   /* inserts a scalar value in the target matrix */
-  EIGEN_DEVICE_FUNC
-  CommaInitializer& operator,(const Scalar& s)
-  {
-    if (m_col==m_xpr.cols())
-    {
-      m_row+=m_currentBlockRows;
+  EIGEN_DEVICE_FUNC CommaInitializer &operator,(const Scalar& s) {
+    if (m_col == m_xpr.cols()) {
+      m_row += m_currentBlockRows;
       m_col = 0;
       m_currentBlockRows = 1;
-      eigen_assert(m_row<m_xpr.rows()
-        && "Too many rows passed to comma initializer (operator<<)");
+      eigen_assert(m_row < m_xpr.rows() && "Too many rows passed to comma initializer (operator<<)");
     }
-    eigen_assert(m_col<m_xpr.cols()
-      && "Too many coefficients passed to comma initializer (operator<<)");
-    eigen_assert(m_currentBlockRows==1);
+    eigen_assert(m_col < m_xpr.cols() && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows == 1);
     m_xpr.coeffRef(m_row, m_col++) = s;
     return *this;
   }
 
   /* inserts a matrix expression in the target matrix */
-  template<typename OtherDerived>
-  EIGEN_DEVICE_FUNC
-  CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
-  {
-    if (m_col==m_xpr.cols() && (other.cols()!=0 || other.rows()!=m_currentBlockRows))
-    {
-      m_row+=m_currentBlockRows;
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC CommaInitializer &operator,(const DenseBase<OtherDerived>& other) {
+    if (m_col == m_xpr.cols() && (other.cols() != 0 || other.rows() != m_currentBlockRows)) {
+      m_row += m_currentBlockRows;
       m_col = 0;
       m_currentBlockRows = other.rows();
-      eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows()
-        && "Too many rows passed to comma initializer (operator<<)");
+      eigen_assert(m_row + m_currentBlockRows <= m_xpr.rows() &&
+                   "Too many rows passed to comma initializer (operator<<)");
     }
-    eigen_assert((m_col + other.cols() <= m_xpr.cols())
-      && "Too many coefficients passed to comma initializer (operator<<)");
-    eigen_assert(m_currentBlockRows==other.rows());
-    m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>
-                    (m_row, m_col, other.rows(), other.cols()) = other;
+    eigen_assert((m_col + other.cols() <= m_xpr.cols()) &&
+                 "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows == other.rows());
+    m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>(m_row, m_col, other.rows(),
+                                                                                           other.cols()) = other;
     m_col += other.cols();
     return *this;
   }
 
-  EIGEN_DEVICE_FUNC
-  inline ~CommaInitializer()
+  EIGEN_DEVICE_FUNC inline ~CommaInitializer()
 #if defined VERIFY_RAISES_ASSERT && (!defined EIGEN_NO_ASSERTION_CHECKING) && defined EIGEN_EXCEPTIONS
-  EIGEN_EXCEPTION_SPEC(Eigen::eigen_assert_exception)
+      noexcept(false)  // Eigen::eigen_assert_exception
 #endif
   {
     finished();
   }
 
   /** \returns the built matrix once all its coefficients have been set.
-    * Calling finished is 100% optional. Its purpose is to write expressions
-    * like this:
-    * \code
-    * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
-    * \endcode
-    */
-  EIGEN_DEVICE_FUNC
-  inline XprType& finished() {
-      eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0)
-           && m_col == m_xpr.cols()
-           && "Too few coefficients passed to comma initializer (operator<<)");
-      return m_xpr;
+   * Calling finished is 100% optional. Its purpose is to write expressions
+   * like this:
+   * \code
+   * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
+   * \endcode
+   */
+  EIGEN_DEVICE_FUNC inline XprType& finished() {
+    eigen_assert(((m_row + m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0) && m_col == m_xpr.cols() &&
+                 "Too few coefficients passed to comma initializer (operator<<)");
+    return m_xpr;
   }
 
-  XprType& m_xpr;           // target expression
-  Index m_row;              // current row id
-  Index m_col;              // current col id
-  Index m_currentBlockRows; // current block height
+  XprType& m_xpr;            // target expression
+  Index m_row;               // current row id
+  Index m_col;               // current col id
+  Index m_currentBlockRows;  // current block height
 };
 
 /** \anchor MatrixBaseCommaInitRef
-  * Convenient operator to set the coefficients of a matrix.
-  *
-  * The coefficients must be provided in a row major order and exactly match
-  * the size of the matrix. Otherwise an assertion is raised.
-  *
-  * Example: \include MatrixBase_set.cpp
-  * Output: \verbinclude MatrixBase_set.out
-  * 
-  * \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order.
-  *
-  * \sa CommaInitializer::finished(), class CommaInitializer
-  */
-template<typename Derived>
-EIGEN_DEVICE_FUNC inline CommaInitializer<Derived> DenseBase<Derived>::operator<< (const Scalar& s)
-{
+ * Convenient operator to set the coefficients of a matrix.
+ *
+ * The coefficients must be provided in a row major order and exactly match
+ * the size of the matrix. Otherwise an assertion is raised.
+ *
+ * Example: \include MatrixBase_set.cpp
+ * Output: \verbinclude MatrixBase_set.out
+ *
+ * \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary
+ * order.
+ *
+ * \sa CommaInitializer::finished(), class CommaInitializer
+ */
+template <typename Derived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived> DenseBase<Derived>::operator<<(const Scalar& s) {
   return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
 }
 
 /** \sa operator<<(const Scalar&) */
-template<typename Derived>
-template<typename OtherDerived>
-EIGEN_DEVICE_FUNC inline CommaInitializer<Derived>
-DenseBase<Derived>::operator<<(const DenseBase<OtherDerived>& other)
-{
-  return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
+template <typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived> DenseBase<Derived>::operator<<(
+    const DenseBase<OtherDerived>& other) {
+  return CommaInitializer<Derived>(*static_cast<Derived*>(this), other);
 }
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_COMMAINITIALIZER_H
+#endif  // EIGEN_COMMAINITIALIZER_H

package/eigen/Eigen/src/Core/ConditionEstimator.h

@@ -10,6 +10,9 @@
 #ifndef EIGEN_CONDITIONESTIMATOR_H
 #define EIGEN_CONDITIONESTIMATOR_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 
 namespace internal {
@@ -19,7 +22,7 @@ struct rcond_compute_sign {
   static inline Vector run(const Vector& v) {
     const RealVector v_abs = v.cwiseAbs();
     return (v_abs.array() == static_cast<typename Vector::RealScalar>(0))
-            .select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs));
+        .select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs));
   }
 };
 
@@ -28,33 +31,32 @@ template <typename Vector>
 struct rcond_compute_sign<Vector, Vector, false> {
   static inline Vector run(const Vector& v) {
     return (v.array() < static_cast<typename Vector::RealScalar>(0))
-           .select(-Vector::Ones(v.size()), Vector::Ones(v.size()));
+        .select(-Vector::Ones(v.size()), Vector::Ones(v.size()));
   }
 };
 
 /**
-  * \returns an estimate of ||inv(matrix)||_1 given a decomposition of
-  * \a matrix that implements .solve() and .adjoint().solve() methods.
-  *
-  * This function implements Algorithms 4.1 and 5.1 from
-  *   http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf
-  * which also forms the basis for the condition number estimators in
-  * LAPACK. Since at most 10 calls to the solve method of dec are
-  * performed, the total cost is O(dims^2), as opposed to O(dims^3)
-  * needed to compute the inverse matrix explicitly.
-  *
-  * The most common usage is in estimating the condition number
-  * ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be
-  * computed directly in O(n^2) operations.
-  *
-  * Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and
-  * LLT.
-  *
-  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
-  */
+ * \returns an estimate of ||inv(matrix)||_1 given a decomposition of
+ * \a matrix that implements .solve() and .adjoint().solve() methods.
+ *
+ * This function implements Algorithms 4.1 and 5.1 from
+ *   http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf
+ * which also forms the basis for the condition number estimators in
+ * LAPACK. Since at most 10 calls to the solve method of dec are
+ * performed, the total cost is O(dims^2), as opposed to O(dims^3)
+ * needed to compute the inverse matrix explicitly.
+ *
+ * The most common usage is in estimating the condition number
+ * ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be
+ * computed directly in O(n^2) operations.
+ *
+ * Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and
+ * LLT.
+ *
+ * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+ */
 template <typename Decomposition>
-typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec)
-{
+typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec) {
   typedef typename Decomposition::MatrixType MatrixType;
   typedef typename Decomposition::Scalar Scalar;
   typedef typename Decomposition::RealScalar RealScalar;
@@ -64,17 +66,16 @@ typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomp
 
   eigen_assert(dec.rows() == dec.cols());
   const Index n = dec.rows();
-  if (n == 0)
-    return 0;
+  if (n == 0) return 0;
 
-  // Disable Index to float conversion warning
+    // Disable Index to float conversion warning
 #ifdef __INTEL_COMPILER
-  #pragma warning push
-  #pragma warning ( disable : 2259 )
+#pragma warning push
+#pragma warning(disable : 2259)
 #endif
   Vector v = dec.solve(Vector::Ones(n) / Scalar(n));
 #ifdef __INTEL_COMPILER
-  #pragma warning pop
+#pragma warning pop
 #endif
 
   // lower_bound is a lower bound on
@@ -82,8 +83,7 @@ typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomp
   // and is the objective maximized by the ("super-") gradient ascent
   // algorithm below.
   RealScalar lower_bound = v.template lpNorm<1>();
-  if (n == 1)
-    return lower_bound;
+  if (n == 1) return lower_bound;
 
   // Gradient ascent algorithm follows: We know that the optimum is achieved at
   // one of the simplices v = e_i, so in each iteration we follow a
@@ -93,8 +93,7 @@ typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomp
   Vector old_sign_vector;
   Index v_max_abs_index = -1;
   Index old_v_max_abs_index = v_max_abs_index;
-  for (int k = 0; k < 4; ++k)
-  {
+  for (int k = 0; k < 4; ++k) {
     sign_vector = internal::rcond_compute_sign<Vector, RealVector, is_complex>::run(v);
     if (k > 0 && !is_complex && sign_vector == old_sign_vector) {
       // Break if the solution stagnated.
@@ -142,30 +141,29 @@ typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomp
 }
 
 /** \brief Reciprocal condition number estimator.
-  *
-  * Computing a decomposition of a dense matrix takes O(n^3) operations, while
-  * this method estimates the condition number quickly and reliably in O(n^2)
-  * operations.
-  *
-  * \returns an estimate of the reciprocal condition number
-  * (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and
-  * its decomposition. Supports the following decompositions: FullPivLU,
-  * PartialPivLU, LDLT, and LLT.
-  *
-  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
-  */
+ *
+ * Computing a decomposition of a dense matrix takes O(n^3) operations, while
+ * this method estimates the condition number quickly and reliably in O(n^2)
+ * operations.
+ *
+ * \returns an estimate of the reciprocal condition number
+ * (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and
+ * its decomposition. Supports the following decompositions: FullPivLU,
+ * PartialPivLU, LDLT, and LLT.
+ *
+ * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+ */
 template <typename Decomposition>
-typename Decomposition::RealScalar
-rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition& dec)
-{
+typename Decomposition::RealScalar rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm,
+                                                         const Decomposition& dec) {
   typedef typename Decomposition::RealScalar RealScalar;
   eigen_assert(dec.rows() == dec.cols());
-  if (dec.rows() == 0)              return NumTraits<RealScalar>::infinity();
-  if (matrix_norm == RealScalar(0)) return RealScalar(0);
-  if (dec.rows() == 1)              return RealScalar(1);
+  if (dec.rows() == 0) return NumTraits<RealScalar>::infinity();
+  if (numext::is_exactly_zero(matrix_norm)) return RealScalar(0);
+  if (dec.rows() == 1) return RealScalar(1);
   const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec);
-  return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0)
-                                               : (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
+  return (numext::is_exactly_zero(inverse_matrix_norm) ? RealScalar(0)
+                                                       : (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
 }
 
 }  // namespace internal