@smake/eigen 1.1.0 → 1.1.1

package/eigen/Eigen/src/SparseCore/SparseTriangularView.h

@@ -11,179 +11,167 @@
 #ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
 #define EIGEN_SPARSE_TRIANGULARVIEW_H
 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
 namespace Eigen {
 
 /** \ingroup SparseCore_Module
-  *
-  * \brief Base class for a triangular part in a \b sparse matrix
-  *
-  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
-  * It extends class TriangularView with additional methods which are available for sparse expressions only.
-  *
-  * \sa class TriangularView, SparseMatrixBase::triangularView()
-  */
-template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
-  : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
-{
-    enum { SkipFirst = ((Mode&Lower) && !(MatrixType::Flags&RowMajorBit))
-                    || ((Mode&Upper) &&  (MatrixType::Flags&RowMajorBit)),
-           SkipLast = !SkipFirst,
-           SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
-           HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
-    };
-    
-    typedef TriangularView<MatrixType,Mode> TriangularViewType;
-    
-  protected:
-    // dummy solve function to make TriangularView happy.
-    void solve() const;
-
-    typedef SparseMatrixBase<TriangularViewType> Base;
-  public:
-    
-    EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
-    
-    typedef typename MatrixType::Nested MatrixTypeNested;
-    typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
-    typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
-
-    template<typename RhsType, typename DstType>
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
-      if(!(internal::is_same<RhsType,DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
-        dst = rhs;
-      this->solveInPlace(dst);
-    }
+ *
+ * \brief Base class for a triangular part in a \b sparse matrix
+ *
+ * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be
+ * instantiated. It extends class TriangularView with additional methods which are available for sparse expressions
+ * only.
+ *
+ * \sa class TriangularView, SparseMatrixBase::triangularView()
+ */
+template <typename MatrixType, unsigned int Mode>
+class TriangularViewImpl<MatrixType, Mode, Sparse> : public SparseMatrixBase<TriangularView<MatrixType, Mode> > {
+  enum {
+    SkipFirst =
+        ((Mode & Lower) && !(MatrixType::Flags & RowMajorBit)) || ((Mode & Upper) && (MatrixType::Flags & RowMajorBit)),
+    SkipLast = !SkipFirst,
+    SkipDiag = (Mode & ZeroDiag) ? 1 : 0,
+    HasUnitDiag = (Mode & UnitDiag) ? 1 : 0
+  };
+
+  typedef TriangularView<MatrixType, Mode> TriangularViewType;
 
-    /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
-    template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;
+ protected:
+  // dummy solve function to make TriangularView happy.
+  void solve() const;
+
+  typedef SparseMatrixBase<TriangularViewType> Base;
+
+ public:
+  EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
+
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNestedNonRef;
+  typedef internal::remove_all_t<MatrixTypeNested> MatrixTypeNestedCleaned;
+
+  template <typename RhsType, typename DstType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _solve_impl(const RhsType& rhs, DstType& dst) const {
+    if (!(internal::is_same<RhsType, DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
+      dst = rhs;
+    this->solveInPlace(dst);
+  }
 
-    /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
-    template<typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
-  
+  /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
+  template <typename OtherDerived>
+  void solveInPlace(MatrixBase<OtherDerived>& other) const;
+
+  /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
+  template <typename OtherDerived>
+  void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
 };
 
 namespace internal {
 
-template<typename ArgType, unsigned int Mode>
-struct unary_evaluator<TriangularView<ArgType,Mode>, IteratorBased>
- : evaluator_base<TriangularView<ArgType,Mode> >
-{
-  typedef TriangularView<ArgType,Mode> XprType;
-  
-protected:
-  
+template <typename ArgType, unsigned int Mode>
+struct unary_evaluator<TriangularView<ArgType, Mode>, IteratorBased> : evaluator_base<TriangularView<ArgType, Mode> > {
+  typedef TriangularView<ArgType, Mode> XprType;
+
+ protected:
   typedef typename XprType::Scalar Scalar;
   typedef typename XprType::StorageIndex StorageIndex;
   typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
-  
-  enum { SkipFirst = ((Mode&Lower) && !(ArgType::Flags&RowMajorBit))
-                    || ((Mode&Upper) &&  (ArgType::Flags&RowMajorBit)),
-         SkipLast = !SkipFirst,
-         SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
-         HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
-  };
-  
-public:
-  
+
   enum {
-    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
-    Flags = XprType::Flags
+    SkipFirst =
+        ((Mode & Lower) && !(ArgType::Flags & RowMajorBit)) || ((Mode & Upper) && (ArgType::Flags & RowMajorBit)),
+    SkipLast = !SkipFirst,
+    SkipDiag = (Mode & ZeroDiag) ? 1 : 0,
+    HasUnitDiag = (Mode & UnitDiag) ? 1 : 0
   };
-    
-  explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
-  
-  inline Index nonZerosEstimate() const {
-    return m_argImpl.nonZerosEstimate();
-  }
-  
-  class InnerIterator : public EvalIterator
-  {
-      typedef EvalIterator Base;
-    public:
-
-      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
-        : Base(xprEval.m_argImpl,outer), m_returnOne(false), m_containsDiag(Base::outer()<xprEval.m_arg.innerSize())
-      {
-        if(SkipFirst)
-        {
-          while((*this) && ((HasUnitDiag||SkipDiag)  ? this->index()<=outer : this->index()<outer))
-            Base::operator++();
-          if(HasUnitDiag)
-            m_returnOne = m_containsDiag;
-        }
-        else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
-        {
-          if((!SkipFirst) && Base::operator bool())
-            Base::operator++();
-          m_returnOne = m_containsDiag;
-        }
-      }
 
-      EIGEN_STRONG_INLINE InnerIterator& operator++()
-      {
-        if(HasUnitDiag && m_returnOne)
-          m_returnOne = false;
-        else
-        {
+ public:
+  enum { CoeffReadCost = evaluator<ArgType>::CoeffReadCost, Flags = XprType::Flags };
+
+  explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
+
+  inline Index nonZerosEstimate() const { return m_argImpl.nonZerosEstimate(); }
+
+  class InnerIterator : public EvalIterator {
+    typedef EvalIterator Base;
+
+   public:
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
+        : Base(xprEval.m_argImpl, outer),
+          m_returnOne(false),
+          m_containsDiag(Base::outer() < xprEval.m_arg.innerSize()) {
+      if (SkipFirst) {
+        while ((*this) && ((HasUnitDiag || SkipDiag) ? this->index() <= outer : this->index() < outer))
           Base::operator++();
-          if(HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index()>=Base::outer()))
-          {
-            if((!SkipFirst) && Base::operator bool())
-              Base::operator++();
-            m_returnOne = m_containsDiag;
-          }
-        }
-        return *this;
+        if (HasUnitDiag) m_returnOne = m_containsDiag;
+      } else if (HasUnitDiag && ((!Base::operator bool()) || Base::index() >= Base::outer())) {
+        if ((!SkipFirst) && Base::operator bool()) Base::operator++();
+        m_returnOne = m_containsDiag;
       }
-      
-      EIGEN_STRONG_INLINE operator bool() const
-      {
-        if(HasUnitDiag && m_returnOne)
-          return true;
-        if(SkipFirst) return  Base::operator bool();
-        else
-        {
-          if (SkipDiag) return (Base::operator bool() && this->index() < this->outer());
-          else return (Base::operator bool() && this->index() <= this->outer());
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++() {
+      if (HasUnitDiag && m_returnOne)
+        m_returnOne = false;
+      else {
+        Base::operator++();
+        if (HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index() >= Base::outer())) {
+          if ((!SkipFirst) && Base::operator bool()) Base::operator++();
+          m_returnOne = m_containsDiag;
         }
       }
+      return *this;
+    }
 
-//       inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
-//       inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
-      inline StorageIndex index() const
-      {
-        if(HasUnitDiag && m_returnOne)  return internal::convert_index<StorageIndex>(Base::outer());
-        else                            return Base::index();
-      }
-      inline Scalar value() const
-      {
-        if(HasUnitDiag && m_returnOne)  return Scalar(1);
-        else                            return Base::value();
+    EIGEN_STRONG_INLINE operator bool() const {
+      if (HasUnitDiag && m_returnOne) return true;
+      if (SkipFirst)
+        return Base::operator bool();
+      else {
+        if (SkipDiag)
+          return (Base::operator bool() && this->index() < this->outer());
+        else
+          return (Base::operator bool() && this->index() <= this->outer());
       }
+    }
 
-    protected:
-      bool m_returnOne;
-      bool m_containsDiag;
-    private:
-      Scalar& valueRef();
+    inline Index row() const { return (ArgType::Flags & RowMajorBit ? Base::outer() : this->index()); }
+    inline Index col() const { return (ArgType::Flags & RowMajorBit ? this->index() : Base::outer()); }
+    inline StorageIndex index() const {
+      if (HasUnitDiag && m_returnOne)
+        return internal::convert_index<StorageIndex>(Base::outer());
+      else
+        return Base::index();
+    }
+    inline Scalar value() const {
+      if (HasUnitDiag && m_returnOne)
+        return Scalar(1);
+      else
+        return Base::value();
+    }
+
+   protected:
+    bool m_returnOne;
+    bool m_containsDiag;
+
+   private:
+    Scalar& valueRef();
   };
-  
-protected:
+
+ protected:
   evaluator<ArgType> m_argImpl;
   const ArgType& m_arg;
 };
 
-} // end namespace internal
+}  // end namespace internal
 
-template<typename Derived>
-template<int Mode>
-inline const TriangularView<const Derived, Mode>
-SparseMatrixBase<Derived>::triangularView() const
-{
+template <typename Derived>
+template <int Mode>
+inline const TriangularView<const Derived, Mode> SparseMatrixBase<Derived>::triangularView() const {
   return TriangularView<const Derived, Mode>(derived());
 }
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_SPARSE_TRIANGULARVIEW_H
+#endif  // EIGEN_SPARSE_TRIANGULARVIEW_H

package/eigen/Eigen/src/SparseCore/SparseUtil.h

@@ -10,7 +10,10 @@
 #ifndef EIGEN_SPARSEUTIL_H
 #define EIGEN_SPARSEUTIL_H
 
-namespace Eigen { 
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
 
 #ifdef NDEBUG
 #define EIGEN_DBG_SPARSE(X)
@@ -18,127 +21,149 @@ namespace Eigen {
 #define EIGEN_DBG_SPARSE(X) X
 #endif
 
-#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
-template<typename OtherDerived> \
-EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) \
-{ \
-  return Base::operator Op(other.derived()); \
-} \
-EIGEN_STRONG_INLINE Derived& operator Op(const Derived& other) \
-{ \
-  return Base::operator Op(other); \
-}
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op)                                    \
+  template <typename OtherDerived>                                                               \
+  EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) { \
+    return Base::operator Op(other.derived());                                                   \
+  }                                                                                              \
+  EIGEN_STRONG_INLINE Derived& operator Op(const Derived & other) { return Base::operator Op(other); }
 
 #define EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
-template<typename Other> \
-EIGEN_STRONG_INLINE Derived& operator Op(const Other& scalar) \
-{ \
-  return Base::operator Op(scalar); \
-}
-
-#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
-EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =)
-
-
-#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) \
-  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
-
-  
-const int CoherentAccessPattern     = 0x1;
-const int InnerRandomAccessPattern  = 0x2 | CoherentAccessPattern;
-const int OuterRandomAccessPattern  = 0x4 | CoherentAccessPattern;
-const int RandomAccessPattern       = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
-
-template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseMatrix;
-template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class DynamicSparseMatrix;
-template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseVector;
-template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class MappedSparseMatrix;
-
-template<typename MatrixType, unsigned int UpLo>  class SparseSelfAdjointView;
-template<typename Lhs, typename Rhs>              class SparseDiagonalProduct;
-template<typename MatrixType> class SparseView;
-
-template<typename Lhs, typename Rhs>        class SparseSparseProduct;
-template<typename Lhs, typename Rhs>        class SparseTimeDenseProduct;
-template<typename Lhs, typename Rhs>        class DenseTimeSparseProduct;
-template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct;
-
-template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType;
-template<typename Lhs, typename Rhs,
-         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType;
-         
-template<typename Lhs, typename Rhs,
-         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType;
-template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct;
+  template <typename Other>                                          \
+  EIGEN_STRONG_INLINE Derived& operator Op(const Other & scalar) {   \
+    return Base::operator Op(scalar);                                \
+  }
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATORS(Derived) EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =)
+
+#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
+
+const int CoherentAccessPattern = 0x1;
+const int InnerRandomAccessPattern = 0x2 | CoherentAccessPattern;
+const int OuterRandomAccessPattern = 0x4 | CoherentAccessPattern;
+const int RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
+
+template <typename Scalar_, int Flags_ = 0, typename StorageIndex_ = int>
+class SparseMatrix;
+template <typename Scalar_, int Flags_ = 0, typename StorageIndex_ = int>
+class SparseVector;
+
+template <typename MatrixType, unsigned int UpLo>
+class SparseSelfAdjointView;
+template <typename Lhs, typename Rhs>
+class SparseDiagonalProduct;
+template <typename MatrixType>
+class SparseView;
+
+template <typename Lhs, typename Rhs>
+class SparseSparseProduct;
+template <typename Lhs, typename Rhs>
+class SparseTimeDenseProduct;
+template <typename Lhs, typename Rhs>
+class DenseTimeSparseProduct;
+template <typename Lhs, typename Rhs, bool Transpose>
+class SparseDenseOuterProduct;
+
+template <typename Lhs, typename Rhs>
+struct SparseSparseProductReturnType;
+template <typename Lhs, typename Rhs,
+          int InnerSize = internal::min_size_prefer_fixed(internal::traits<Lhs>::ColsAtCompileTime,
+                                                          internal::traits<Rhs>::RowsAtCompileTime)>
+struct DenseSparseProductReturnType;
+
+template <typename Lhs, typename Rhs,
+          int InnerSize = internal::min_size_prefer_fixed(internal::traits<Lhs>::ColsAtCompileTime,
+                                                          internal::traits<Rhs>::RowsAtCompileTime)>
+struct SparseDenseProductReturnType;
+template <typename MatrixType, int UpLo>
+class SparseSymmetricPermutationProduct;
 
 namespace internal {
 
-template<typename T,int Rows,int Cols,int Flags> struct sparse_eval;
+template <typename T, int Rows, int Cols, int Flags>
+struct sparse_eval;
+
+template <typename T>
+struct eval<T, Sparse> : sparse_eval<T, traits<T>::RowsAtCompileTime, traits<T>::ColsAtCompileTime, traits<T>::Flags> {
+};
 
-template<typename T> struct eval<T,Sparse>
-  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime,traits<T>::Flags>
-{};
+template <typename T, int Cols, int Flags>
+struct sparse_eval<T, 1, Cols, Flags> {
+  typedef typename traits<T>::Scalar Scalar_;
+  typedef typename traits<T>::StorageIndex StorageIndex_;
 
-template<typename T,int Cols,int Flags> struct sparse_eval<T,1,Cols,Flags> {
-    typedef typename traits<T>::Scalar _Scalar;
-    typedef typename traits<T>::StorageIndex _StorageIndex;
-  public:
-    typedef SparseVector<_Scalar, RowMajor, _StorageIndex> type;
+ public:
+  typedef SparseVector<Scalar_, RowMajor, StorageIndex_> type;
 };
 
-template<typename T,int Rows,int Flags> struct sparse_eval<T,Rows,1,Flags> {
-    typedef typename traits<T>::Scalar _Scalar;
-    typedef typename traits<T>::StorageIndex _StorageIndex;
-  public:
-    typedef SparseVector<_Scalar, ColMajor, _StorageIndex> type;
+template <typename T, int Rows, int Flags>
+struct sparse_eval<T, Rows, 1, Flags> {
+  typedef typename traits<T>::Scalar Scalar_;
+  typedef typename traits<T>::StorageIndex StorageIndex_;
+
+ public:
+  typedef SparseVector<Scalar_, ColMajor, StorageIndex_> type;
 };
 
 // TODO this seems almost identical to plain_matrix_type<T, Sparse>
-template<typename T,int Rows,int Cols,int Flags> struct sparse_eval {
-    typedef typename traits<T>::Scalar _Scalar;
-    typedef typename traits<T>::StorageIndex _StorageIndex;
-    enum { _Options = ((Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
-  public:
-    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+template <typename T, int Rows, int Cols, int Flags>
+struct sparse_eval {
+  typedef typename traits<T>::Scalar Scalar_;
+  typedef typename traits<T>::StorageIndex StorageIndex_;
+  enum { Options_ = ((Flags & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor };
+
+ public:
+  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> type;
 };
 
-template<typename T,int Flags> struct sparse_eval<T,1,1,Flags> {
-    typedef typename traits<T>::Scalar _Scalar;
-  public:
-    typedef Matrix<_Scalar, 1, 1> type;
+template <typename T, int Flags>
+struct sparse_eval<T, 1, 1, Flags> {
+  typedef typename traits<T>::Scalar Scalar_;
+
+ public:
+  typedef Matrix<Scalar_, 1, 1> type;
 };
 
-template<typename T> struct plain_matrix_type<T,Sparse>
-{
-  typedef typename traits<T>::Scalar _Scalar;
-  typedef typename traits<T>::StorageIndex _StorageIndex;
-  enum { _Options = ((evaluator<T>::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
-  public:
-    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+template <typename T>
+struct plain_matrix_type<T, Sparse> {
+  typedef typename traits<T>::Scalar Scalar_;
+  typedef typename traits<T>::StorageIndex StorageIndex_;
+  enum { Options_ = ((evaluator<T>::Flags & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor };
+
+ public:
+  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> type;
 };
 
-template<typename T>
-struct plain_object_eval<T,Sparse>
-  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime, evaluator<T>::Flags>
-{};
+template <typename T>
+struct plain_object_eval<T, Sparse>
+    : sparse_eval<T, traits<T>::RowsAtCompileTime, traits<T>::ColsAtCompileTime, evaluator<T>::Flags> {};
 
-template<typename Decomposition, typename RhsType>
-struct solve_traits<Decomposition,RhsType,Sparse>
-{
-  typedef typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,traits<RhsType>::Flags>::type PlainObject;
+template <typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition, RhsType, Sparse> {
+  typedef typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,
+                               traits<RhsType>::Flags>::type PlainObject;
 };
 
-template<typename Derived>
-struct generic_xpr_base<Derived, MatrixXpr, Sparse>
-{
+template <typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, Sparse> {
   typedef SparseMatrixBase<Derived> type;
 };
 
-struct SparseTriangularShape  { static std::string debugName() { return "SparseTriangularShape"; } };
-struct SparseSelfAdjointShape { static std::string debugName() { return "SparseSelfAdjointShape"; } };
+struct SparseTriangularShape {
+  static std::string debugName() { return "SparseTriangularShape"; }
+};
+struct SparseSelfAdjointShape {
+  static std::string debugName() { return "SparseSelfAdjointShape"; }
+};
 
-template<> struct glue_shapes<SparseShape,SelfAdjointShape> { typedef SparseSelfAdjointShape type;  };
-template<> struct glue_shapes<SparseShape,TriangularShape > { typedef SparseTriangularShape  type;  };
+template <>
+struct glue_shapes<SparseShape, SelfAdjointShape> {
+  typedef SparseSelfAdjointShape type;
+};
+template <>
+struct glue_shapes<SparseShape, TriangularShape> {
+  typedef SparseTriangularShape type;
+};
 
 // return type of SparseCompressedBase::lower_bound;
 struct LowerBoundIndex {
@@ -148,25 +173,22 @@ struct LowerBoundIndex {
   bool found;
 };
 
-} // end namespace internal
+}  // end namespace internal
 
 /** \ingroup SparseCore_Module
-  *
-  * \class Triplet
-  *
-  * \brief A small structure to hold a non zero as a triplet (i,j,value).
-  *
-  * \sa SparseMatrix::setFromTriplets()
-  */
-template<typename Scalar, typename StorageIndex=typename SparseMatrix<Scalar>::StorageIndex >
-class Triplet
-{
-public:
+ *
+ * \class Triplet
+ *
+ * \brief A small structure to hold a non zero as a triplet (i,j,value).
+ *
+ * \sa SparseMatrix::setFromTriplets()
+ */
+template <typename Scalar, typename StorageIndex = typename SparseMatrix<Scalar>::StorageIndex>
+class Triplet {
+ public:
   Triplet() : m_row(0), m_col(0), m_value(0) {}
 
-  Triplet(const StorageIndex& i, const StorageIndex& j, const Scalar& v = Scalar(0))
-    : m_row(i), m_col(j), m_value(v)
-  {}
+  Triplet(const StorageIndex& i, const StorageIndex& j, const Scalar& v = Scalar(0)) : m_row(i), m_col(j), m_value(v) {}
 
   /** \returns the row index of the element */
   const StorageIndex& row() const { return m_row; }
@@ -176,11 +198,12 @@ public:
 
   /** \returns the value of the element */
   const Scalar& value() const { return m_value; }
-protected:
+
+ protected:
   StorageIndex m_row, m_col;
   Scalar m_value;
 };
 
-} // end namespace Eigen
+}  // end namespace Eigen
 
-#endif // EIGEN_SPARSEUTIL_H
+#endif  // EIGEN_SPARSEUTIL_H